როგორ გავიგოთ და ოპტიმიზაცია გავუკეთოთ GPU მეხსიერებას PyTorch-ში
ეს გაკვეთილი ეტაპობრივად განმარტავს, თუ როგორ მოვახდინოთ GPU მეხსიერების გამოყენების ვიზუალიზაცია და გაგება PyTorch-ში ტრენინგის დროს. ის მოიცავს მეხსიერების მოთხოვნების შეფასებას, გამოყენების ოპტიმიზაციას PyTorch-ის პროფილის ხელსაწყოების მეშვეობით და დეტალურ ანალიზს იმის შესახებ, თუ როგორ იქცევა მეხსიერება მოდელის შექმნის, წინსვლის, უკუგადაცემის და ოპტიმიზატორის ნაბიჯების განმავლობაში, მათ შორის დიდი ენობრივი მოდელების (LLM) რეალურ სცენარებში.
მიუხედავად იმისა, რომ მარტივია იმის დანახვა, რომ GPU მეხსიერება სავსეა, იმის გაგება, თუ რატომ ხდება ეს და როგორ მოვაგვაროთ პრობლემა, შეიძლება უფრო რთული იყოს. ამ გაკვეთილში, ეტაპობრივად განვიხილავთ, თუ როგორ მოვახდინოთ GPU მეხსიერების გამოყენების ვიზუალიზაცია და გაგება PyTorch-ში ტრენინგის დროს. ასევე ვნახავთ, როგორ შევაფასოთ მეხსიერების მოთხოვნები და მოვახდინოთ GPU მეხსიერების გამოყენების ოპტიმიზაცია. PyTorch გთავაზობთ მოსახერხებელ ინსტრუმენტს GPU მეხსიერების გამოყენების ვიზუალიზაციისთვის: ამ კოდის გაშვება წარმოქმნის `profile.pkl` ფაილს, რომელიც შეიცავს GPU მეხსიერების გამოყენების ისტორიას შესრულების დროს. ამ ისტორიის ვიზუალიზაცია შეგიძლიათ: [https://pytorch.org/memory_viz](https://pytorch.org/memory_viz)-ზე. თქვენი `profile.pkl` ფაილის გადათრევითა და ჩამოგდებით, ნახავთ ასეთ გრაფიკს:
მოდით, დავყოთ ეს გრაფიკი ძირითად ნაწილებად:
* **მოდელის შექმნა:** მეხსიერება იზრდება 2 GB-ით, რაც შეესაბამება მოდელის ზომას: `10,000×50,000` წონა + `50,000` გადახრა `float32`-ში (4 ბაიტი) `⟹ (5×10⁸)×4` ბაიტი `= 2 GB`. ეს მეხსიერება (ლურჯ ფერში) რჩება შესრულების განმავლობაში.
* **შემავალი ტენზორის შექმნა (1-ლი ციკლი):** მეხსიერება იზრდება 200 MB-ით, რაც შეესაბამება შემავალი ტენზორის ზომას: `5,000×10,000` ელემენტი `float32`-ში (4 ბაიტი) `⟹ (5×10⁷)×4` ბაიტი `= 0.2 GB`.
* **პირდაპირი გადაცემა (1-ლი ციკლი):** მეხსიერება იზრდება 1 GB-ით გამომავალი ტენზორისთვის: `5,000×50,000` ელემენტი `float32`-ში (4 ბაიტი) `⟹ (25×10⁷)×4` ბაიტი `= 1 GB`.
* **შემავალი ტენზორის შექმნა (მე-2 ციკლი):** მეხსიერება იზრდება 200 MB-ით ახალი შემავალი ტენზორისთვის. ამ ეტაპზე, შეიძლება ელოდეთ, რომ მე-2 ნაბიჯის შემავალი ტენზორი გათავისუფლდება. თუმცა, ასე არ ხდება: მოდელი ინარჩუნებს თავის აქტივაციას, ამიტომ, მაშინაც კი, თუ ტენზორი აღარ არის მინიჭებული ცვლადის `inputs`-ისთვის, ის რჩება მოდელის პირდაპირი გადაცემის გამოთვლის მიერ მითითებული. მოდელი ინარჩუნებს თავის აქტივაციებს, რადგან ეს ტენზორები საჭიროა ნერვულ ქსელებში უკუგადაცემის პროცესისთვის. სცადეთ `torch.no_grad()`-ით განსხვავების სანახავად.
* **პირდაპირი გადაცემა (მე-2 ციკლი):** მეხსიერება იზრდება 1 GB-ით ახალი გამომავალი ტენზორისთვის, გამოთვლილი როგორც მე-3 ნაბიჯში.
* **1-ლი ციკლის აქტივაციის გათავისუფლება:** მეორე ციკლის პირდაპირი გადაცემის შემდეგ, პირველი ციკლის (მე-2 ნაბიჯი) შემავალი ტენზორი შეიძლება გათავისუფლდეს. მოდელის აქტივაციები, რომლებიც პირველ შემავალ ტენზორს ინახავს, გადაიწერება მეორე ციკლის შეყვანით. როგორც კი მეორე ციკლი დასრულდება, პირველი ტენზორი აღარ არის მითითებული და მისი მეხსიერება შეიძლება გათავისუფლდეს.
* **გამოსავლის განახლება:** მე-3 ნაბიჯის გამომავალი ტენზორი ხელახლა ენიჭება ცვლადს `output`. წინა ტენზორი აღარ არის მითითებული და იშლება, რითაც მისი მეხსიერება თავისუფლდება.
* **შემავალი ტენზორის შექმნა (მე-3 ციკლი):** იგივეა, რაც მე-4 ნაბიჯში.
* **პირდაპირი გადაცემა (მე-3 ციკლი):** იგივეა, რაც მე-5 ნაბიჯში.
* **მე-2 ციკლის აქტივაციის გათავისუფლება:** მე-4 ნაბიჯის შემავალი ტენზორი თავისუფლდება.
* **გამოსავლის ხელახლა განახლება:** მე-5 ნაბიჯის გამომავალი ტენზორი ხელახლა ენიჭება ცვლადს `output`, რითაც წინა ტენზორი თავისუფლდება.
* **კოდის შესრულების დასასრული:** მთელი მეხსიერება გათავისუფლებულია.
წინა მაგალითი გამარტივებული იყო. რეალურ სცენარებში, ჩვენ ხშირად ვავარჯიშებთ კომპლექსურ მოდელებს და არა ერთ წრფივ ფენას. გარდა ამისა, ადრინდელი მაგალითი არ მოიცავდა ტრენინგის პროცესს. აქ, ჩვენ შევისწავლით, თუ როგორ იქცევა GPU მეხსიერება სრული ტრენინგის ციკლის განმავლობაში ნამდვილი დიდი ენობრივი მოდელისთვის (LLM).
💡 **რჩევა:** პროფილის შექმნისას, შეზღუდეთ ნაბიჯების რაოდენობა. GPU მეხსიერების ყოველი მოვლენა აღირიცხება და ფაილი შეიძლება ძალიან დიდი გახდეს. მაგალითად, ზემოთ მოცემული კოდი წარმოქმნის 8 MB ფაილს. აქ მოცემულია მეხსიერების პროფილი ამ მაგალითისთვის:
ეს გრაფიკი უფრო კომპლექსურია, ვიდრე წინა მაგალითი, მაგრამ მაინც შეგვიძლია ეტაპობრივად დავშალოთ ის. შეამჩნიეთ სამი ნახტომი, რომელთაგან თითოეული შეესაბამება ტრენინგის ციკლის ერთ იტერაციას. მოდით, გავამარტივოთ გრაფიკი, რათა მისი ინტერპრეტაცია უფრო ადვილი იყოს:
* **მოდელის ინიციალიზაცია** (`model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-1.5B").to("cuda")`):
პირველი ნაბიჯი მოიცავს მოდელის GPU-ზე ჩატვირთვას. მოდელის პარამეტრები (ლურჯ ფერში) იკავებენ მეხსიერებას და რჩებიან იქ ტრენინგის დასრულებამდე.
* **პირდაპირი გადაცემა** (`model(inputs)`):
პირდაპირი გადაცემის დროს, აქტივაციები (თითოეული ფენის შუალედური გამოსავლები) გამოითვლება და ინახება მეხსიერებაში უკუგადაცემისთვის. ეს აქტივაციები, წარმოდგენილი ნარინჯისფერში, იზრდება ფენა-ფენა საბოლოო ფენამდე. დანაკარგი გამოითვლება ნარინჯისფერი ზონის პიკზე.
* **უკუგადაცემა** (`loss.backward()`):
ამ ფაზაში გამოითვლება და ინახება გრადიენტები (ყვითელ ფერში). ამავდროულად, აქტივაციები გაუქმებულია, რადგან ისინი აღარ არის საჭირო, რაც იწვევს ნარინჯისფერი ზონის შემცირებას. ყვითელი ზონა წარმოადგენს მეხსიერების გამოყენებას გრადიენტების გამოთვლებისთვის.
* **ოპტიმიზატორის ნაბიჯი** (`optimizer.step()`):
გრადიენტები გამოიყენება მოდელის პარამეტრების განახლებისთვის. თავდაპირველად, ოპტიმიზატორი...
თეგები:
#llm
#მანქანური სწავლება
#gpu
#ღრმა სწავლება
#pytorch
#მეხსიერების ოპტიმიზაცია
#ტრენინგი
#პროფილის შექმნა
#აქტივაციები
#გრადიენტები
წყარო: huggingface.co
AI-ით გადამუშავებული
მსგავსი სტატიები
ხელოვნური ინტელექტი
Anthropic-ის Claude-ის აღზევება Apple App Store-ის რეიტინგებში პენტაგონთან მოლაპარაკებების ფონზე
ხელოვნური ინტელექტი
ტრამპის ადმინისტრაცია Anthropic-ს სანქციებს უწესებს ხელოვნური ინტელექტის გამოყენებაზე უარის გამო: ექსპერტი ინდუსტრიის უსაფრთხოების ხარვეზებზე საუბრობს
ხელოვნური ინტელექტი