თუმცა, ყველა ეს გაუმჯობესება მიიღწევა მნიშვნელოვნად დიდი მოდელის ხარჯზე. რამდენად დიდის? SDXL-ის საბაზისო მოდელს აქვს 3.5 მილიარდი პარამეტრი (კერძოდ, UNet-ს), რაც დაახლოებით 3-ჯერ აღემატება წინა Stable Diffusion მოდელს. იმის შესასწავლად, თუ როგორ შეგვიძლია SDXL-ის ოპტიმიზაცია ინფერენციის სიჩქარისა და მეხსიერების მოხმარებისთვის, ჩვენ ჩავატარეთ ტესტები A100 GPU-ზე (40 GB). ყოველი ინფერენციისას, ჩვენ ვგენერირებთ 4 გამოსახულებას და ვიმეორებთ ამ პროცესს 3-ჯერ. ინფერენციის ლატენტურობის გამოთვლისას, ჩვენ მხოლოდ ბოლო იტერაციას ვითვალისწინებთ 3-დან. ამრიგად, თუ SDXL-ს გაუშვებთ ისე, როგორც არის, სრული სიზუსტით და ნაგულისხმევი ყურადღების მექანიზმით, ის მოიხმარს 28 GB მეხსიერებას და დასჭირდება 72.2 წამი! ეს არ არის დიდად პრაქტიკული და შეუძლია შეგანელოთ, რადგან ხშირად 4-ზე მეტ გამოსახულებას ქმნით. თუ არ გაქვთ უფრო მძლავრი GPU, თქვენ შეგხვდებათ გამაღიზიანებელი შეცდომა მეხსიერების ამოწურვის შესახებ. მაშ, როგორ შეგვიძლია SDXL-ის ოპტიმიზაცია ინფერენციის სიჩქარის გასაზრდელად და მისი მეხსიერების მოხმარების შესამცირებლად? 🤗 Diffusers-ში ჩვენ გვაქვს ოპტიმიზაციის მრავალი ხრიკი და ტექნიკა, რათა დაგეხმაროთ ისეთი მეხსიერებაზე ინტენსიური მოდელების გაშვებაში, როგორიცაა SDXL და ჩვენ გაჩვენებთ როგორ! ორი ძირითადი რამ, რაზეც ფოკუსირებული ვიქნებით, არის ინფერენციის სიჩქარე და მეხსიერება. დიფუზია შემთხვევითი პროცესია, ამიტომ არ არსებობს გარანტია, რომ მიიღებთ თქვენთვის სასურველ გამოსახულებას. ხშირად, ინფერენციის მრავალჯერ გაშვება და გამეორება დაგჭირდებათ, რის გამოც სიჩქარის ოპტიმიზაცია გადამწყვეტია. ეს სექცია ფოკუსირებულია დაბალი სიზუსტის წონების გამოყენებაზე, მეხსიერებაზე ეფექტური ყურადღების მექანიზმებისა და PyTorch 2.0-ის `torch.compile`-ის ინტეგრირებაზე სიჩქარის გასაზრდელად და ინფერენციის დროის შესამცირებლად. მოდელის წონები ინახება გარკვეული სიზუსტით, რაც გამოიხატება მცურავი წერტილის მონაცემთა ტიპით. სტანდარტული მცურავი წერტილის მონაცემთა ტიპია float32 (fp32), რომელსაც შეუძლია ზუსტად წარმოადგინოს მცურავი რიცხვების ფართო სპექტრი. ინფერენციისთვის, ხშირად არ გჭირდებათ ასეთი სიზუსტე, ამიტომ უნდა გამოიყენოთ float16 (fp16), რომელიც მცურავი რიცხვების უფრო ვიწრო დიაპაზონს აფიქსირებს. ეს ნიშნავს, რომ fp16-ს შესანახად სჭირდება fp32-თან შედარებით ორჯერ ნაკლები მეხსიერება და ორჯერ უფრო სწრაფია, რადგან მისი გამოთვლა უფრო მარტივია. გარდა ამისა, თანამედროვე GPU ბარათებს აქვთ ოპტიმიზებული აპარატურა fp16 გამოთვლების შესასრულებლად, რაც მას კიდევ უფრო აჩქარებს. 🤗 Diffusers-ის საშუალებით, შეგიძლიათ გამოიყენოთ fp16 ინფერენციისთვის `torch.dtype` პარამეტრის მითითებით, რათა მოდელის ჩატვირთვისას წონები გადაიყვანოთ: სრულიად არაოპტიმიზებულ SDXL პაიპლაინთან შედარებით, fp16-ის გამოყენება მოიხმარს 21.7 GB მეხსიერებას და სჭირდება მხოლოდ 14.8 წამი. თქვენ თითქმის მთელი წუთით აჩქარებთ ინფერენციას! ტრანსფორმერების მოდულებში გამოყენებული ყურადღების ბლოკები შეიძლება იყოს უზარმაზარი ბოთლის ყელი, რადგან მეხსიერება კვადრატულად იზრდება შეყვანის თანმიმდევრობების გახანგრძლივებასთან ერთად. ამან შეიძლება სწრაფად მოიხმაროს უამრავი მეხსიერება და დატოვოს მეხსიერების ამოწურვის შეცდომის შეტყობინება. 😬 მეხსიერებაზე ეფექტური ყურადღების ალგორითმები მიზნად ისახავს ყურადღების გამოთვლის მეხსიერების ტვირთის შემცირებას, იქნება ეს მეჩხერობის გამოყენებით თუ ფილების დაგებით (tiling). ეს ოპტიმიზებული ალგორითმები ძირითადად ხელმისაწვდომი იყო მესამე მხარის ბიბლიოთეკების სახით, რომლებიც ცალკე ინსტალაციას საჭიროებდნენ. მაგრამ PyTorch 2.0-დან დაწყებული, ეს აღარ არის ასე. PyTorch 2-მა შემოიღო სკალირებული წერტილოვანი პროდუქტის ყურადღება (SDPA), რომელიც გვთავაზობს Flash Attention-ის, მეხსიერებაზე ეფექტური ყურადღების (xFormers) და C++-ში დაწერილი PyTorch იმპლემენტაციის შერწყმულ ვერსიებს. SDPA ალბათ ინფერენციის დაჩქარების უმარტივესი გზაა: თუ იყენებთ PyTorch ≥ 2.0-ს 🤗 Diffusers-თან ერთად, ის ავტომატურად ჩართულია ნაგულისხმევად! სრულიად არაოპტიმიზებულ SDXL პაიპლაინთან შედარებით, fp16-ისა და SDPA-ის გამოყენება მოიხმარს იგივე რაოდენობის მეხსიერებას და ინფერენციის დრო უმჯობესდება 11.4 წამამდე. მოდით, ეს გამოვიყენოთ, როგორც ახალი ბაზისური მაჩვენებელი, რომელსაც შევადარებთ სხვა ოპტიმიზაციებს. PyTorch 2.0-მა ასევე წარმოადგინა `torch.compile` API just-in-time (JIT) კომპილაციისთვის, რათა თქვენი PyTorch კოდი გადაიყვანოს უფრო ოპტიმიზებულ ბირთვებად ინფერენციისთვის. სხვა კომპილატორის გადაწყვეტილებებისგან განსხვავებით, `torch.compile` მოითხოვს მინიმალურ ცვლილებებს თქვენს არსებულ კოდში და ის ისეთივე მარტივია, როგორც თქვენი მოდელის ამ ფუნქციით შეფუთვა. `mode` პარამეტრით შეგიძლიათ მოახდინოთ ოპტიმიზაცია მეხსიერების ზედმეტი მოხმარებისთვის ან ინფერენციის სიჩქარისთვის კომპილაციის დროს, რაც გაცილებით მეტ მოქნილობას გაძლევთ. წინა ბაზისურ მაჩვენებელთან (fp16 + SDPA) შედარებით, UNet-ის `torch.compile`-ით შეფუთვა აუმჯობესებს ინფერენციის დროს 10.2 წამამდე. დღევანდელი მოდელები სულ უფრო და უფრო იზრდება, რაც მათ მეხსიერებაში მოთავსებას გამოწვევად აქცევს. ეს სექცია ფოკუსირებულია იმაზე, თუ როგორ შეგიძლიათ შეამციროთ ამ უზარმაზარი მოდელების მეხსიერების მოხმარება, რათა ისინი გაუშვათ სამომხმარებლო GPU-ებზე. ეს ტექნიკები მოიცავს CPU-ზე გადმოტვირთვას (CPU offloading), ლატენტების გამოსახულებებად დეკოდირებას რამდენიმე ეტაპად ერთდროულად ყველაფრის ნაცვლად, და ავტოენკოდერის გამოხდილი (distilled) ვერსიის გამოყენებას. მოდელის გადმოტვირთვა ზოგავს მეხსიერებას UNet-ის GPU მეხსიერებაში ჩატვირთვით, ხოლო დიფუზიური მოდელის სხვა კომპონენტები (ტექსტის ენკოდერები, VAE) იტვირთება CPU-ზე. ამ გზით, UNet-ს შეუძლია იმუშაოს მრავალი იტერაციისთვის GPU-ზე, სანამ ის აღარ იქნება საჭირო. ბაზისურ მაჩვენებელთან შედარებით, ახლა მას სჭირდება 20.2 GB მეხსიერება, რაც გიზოგავთ 1.5 GB მეხსიერებას. გადმოტვირთვის კიდევ ერთი ტიპი, რომელსაც შეუძლია მეტი მეხსიერების დაზოგვა, უფრო ნელი ინფერენციის ხარჯზე, არის თანმიმდევრული CPU-ზე გადმოტვირთვა.