როგორ ოპტიმიზაცია გავუკეთოთ ხელოვნური ინტელექტის მოდელებს

როგორ ოპტიმიზაცია გავუკეთოთ ხელოვნური ინტელექტის მოდელებს

მოკლე პასუხი: ხელოვნური ინტელექტის მოდელების ოპტიმიზაციისთვის, აირჩიეთ ერთი ძირითადი შეზღუდვა (შეყოვნება, ღირებულება, მეხსიერება, ხარისხი, სტაბილურობა ან გამტარუნარიანობა), შემდეგ კი რაიმეს შეცვლამდე დააფიქსირეთ სანდო საბაზისო ხაზი. ჯერ მოაშორეთ „მილსადენის“ შეფერხებები, შემდეგ გამოიყენეთ დაბალი რისკის მქონე მიღწევები, როგორიცაა შერეული სიზუსტე და პარტირება; თუ ხარისხი შენარჩუნდება, გადადით კომპილატორის/გაშვების დროის ინსტრუმენტებზე და მხოლოდ ამის შემდეგ შეამცირეთ მოდელის ზომა კვანტიზაციის ან დისტილაციის გზით, საჭიროების შემთხვევაში.

ძირითადი დასკვნები:

შეზღუდვა : აირჩიეთ ერთი ან ორი სამიზნე მეტრიკა; ოპტიმიზაცია კომპრომისების სამყაროა და არა უფასო მოგებების.

გაზომვა : p50/p95/p99-ით რეალური სამუშაო დატვირთვების პროფილირება, გამტარუნარიანობა, გამოყენება და მეხსიერების პიკები.

Pipeline : მოდელთან შეხებამდე გამოასწორეთ ტოკენიზაცია, მონაცემთა ჩამტვირთავები, წინასწარი დამუშავება და პარტიცირება.

სერვირება : გამოიყენეთ ქეშირება, განზრახ პაკეტირება, პარალელური რეგულირება და ყურადღებით დააკვირდით კუდის შეყოვნებას.

დამცავი ბარიერები : შესრულების ყოველი ცვლილების შემდეგ, გაუშვით ოქროსფერი მინიშნებები, დავალებების მეტრიკა და წერტილოვანი შემოწმებები.

როგორ ოპტიმიზაცია გავუკეთოთ ხელოვნური ინტელექტის მოდელებს ინფოგრაფიკაში

🔗 როგორ შევაფასოთ ხელოვნური ინტელექტის მოდელები ეფექტურად.
მოდელების სამართლიანად და სანდოდ შესაფასებლად ძირითადი კრიტერიუმები და ნაბიჯები.

🔗 როგორ გავზომოთ ხელოვნური ინტელექტის მუშაობა რეალური მეტრიკებით.
შედარებისთვის გამოიყენეთ საორიენტაციო მაჩვენებლები, შეყოვნება, ღირებულება და ხარისხის სიგნალები.

🔗 როგორ გამოვცადოთ ხელოვნური ინტელექტის მოდელები წარმოებამდე.
პრაქტიკული ტესტირების სამუშაო პროცესი: მონაცემთა დაყოფა, სტრესული შემთხვევები და მონიტორინგი.

🔗 როგორ გამოვიყენოთ ხელოვნური ინტელექტი კონტენტის შესაქმნელად?
უფრო სწრაფად გადააქციეთ იდეები მონახაზებად სტრუქტურირებული მინიშნებებისა და იტერაციის გამოყენებით.

1) რას ნიშნავს „ოპტიმიზაცია“ პრაქტიკაში (რადგან ყველა მას სხვადასხვაგვარად იყენებს) 🧠

როდესაც ადამიანები ამბობენ „ხელოვნური ინტელექტის მოდელის ოპტიმიზაცია“, ისინი შეიძლება გულისხმობდნენ:

  • გახადეთ ის უფრო სწრაფი (შემცირებული ლატენტობა)

  • გაიაფეთ (ნაკლები GPU საათი, ნაკლები ღრუბლოვანი ხარჯები)

  • შეამცირეთ (მეხსიერების დატვირთვა, კიდეების განლაგება)

  • გახადეთ ის უფრო ზუსტი (ხარისხის გაუმჯობესება, ნაკლები ჰალუცინაციები)

  • გახადეთ ის უფრო სტაბილური (ნაკლები ვარიაცია, ნაკლები ჩავარდნები წარმოებაში)

  • მომსახურების გამარტივება (გამტარუნარიანობა, პარტიული დახარისხება, პროგნოზირებადი შესრულება)

აი, ოდნავ შემაწუხებელი სიმართლე: ამ ყველაფრის ერთდროულად მაქსიმიზაცია შეუძლებელია. ოპტიმიზაცია ბუშტის დაჭიმვას ჰგავს - ერთი მხარე შიგნით შესწიე და მეორე გამოხტება. ყოველთვის არა, მაგრამ საკმარისად ხშირად, რომ კომპრომისები დაგეგმო.

ასე რომ, სანამ რამეს შეეხებით, აირჩიეთ თქვენი ძირითადი შეზღუდვა :

2) როგორ გამოიყურება ხელოვნური ინტელექტის მოდელის ოპტიმიზაციის კარგი ვერსია ✅

ოპტიმიზაციის კარგი ვერსია არ არის უბრალოდ „კვანტიზაციის გამოყენება და ლოცვა“. ეს სისტემაა. საუკეთესო კონფიგურაციებს, როგორც წესი, აქვთ:

  • საბაზისო დონე, რომელსაც ენდობით
    თუ ამჟამინდელი შედეგების რეპროდუცირება არ შეგიძლიათ, არ იცით, რომ რამე გააუმჯობესეთ. მარტივია... მაგრამ ხალხი ამას გამოტოვებს. შემდეგ კი სპირალურად იცვლება.

  • მკაფიო სამიზნე მეტრიკა
    „უფრო სწრაფი“ ბუნდოვანია. „p95-ის შეყოვნების შემცირება 900 მილიწამიდან 300 მილიწამამდე იგივე ხარისხის ქულით“ რეალური მიზანია.

  • ხარისხის დამცავი ბარიერები.
    შესრულების ყველა წარმატება ხარისხის ჩუმად დაკნინების რისკს შეიცავს. თქვენ დაგჭირდებათ ტესტები, შეფასებები ან სულ მცირე, საღი აზრის სიზუსტის კომპლექტი.

  • აპარატურული აღქმა -
    ერთ გრაფიკულ პროცესორზე დამონტაჟებული „სწრაფი“ მოდელი შეიძლება მეორეზე გადაადგილდეს. პროცესორები საკუთარი, განსაკუთრებული სახის ქაოსს წარმოადგენენ.

  • განმეორებითი ცვლილებები და არა დიდი აფეთქებითი გადაწერა.
    როდესაც ერთდროულად ხუთ რამეს ცვლით და შესრულება უმჯობესდება, არ იცით რატომ. რაც... შემაშფოთებელია.

ოპტიმიზაცია გიტარის აწყობას უნდა ჰგავდეს - მცირე კორექტირება, ყურადღებით მოსმენა, გამეორება 🎸. თუ დანებით ჟონგლიორობას ჰგავხართ, რაღაც რიგზე არ არის.

3) შედარების ცხრილი: ხელოვნური ინტელექტის მოდელების ოპტიმიზაციის პოპულარული ვარიანტები 📊

ქვემოთ მოცემულია ოპტიმიზაციის გავრცელებული ხელსაწყოების/მიდგომების სწრაფი და ოდნავ მოუწესრიგებელი შედარებითი ცხრილი. არა, ეს არ არის სრულიად „სამართლიანი“ - რეალურ ცხოვრებაშიც ასე არ არის.

ინსტრუმენტი / ვარიანტი აუდიტორია ფასი რატომ მუშაობს
PyTorch torch.compile ( PyTorch დოკუმენტები ) PyTorch-ის ხალხი უფასო გრაფიკის აღბეჭდვა + კომპილატორის ხრიკები ამცირებს ხარჯებს… ზოგჯერ ეს ჯადოსნურია ✨
ONNX Runtime ( ONNX Runtime დოკუმენტები ) განლაგების გუნდები თავისუფალი ძლიერი დასკვნის ოპტიმიზაცია, ფართო მხარდაჭერა, კარგია სტანდარტიზებული სერვირებისთვის
TensorRT ( NVIDIA TensorRT დოკუმენტაცია ) NVIDIA-ს განლაგება ფასიანი ვიბრაციები (ხშირად კომპლექტში) აგრესიული ბირთვის შერწყმა + ზუსტი დამუშავება, ძალიან სწრაფი დაწკაპუნებისას
DeepSpeed ​​( Zero დოკუმენტები ) სასწავლო გუნდები უფასო მეხსიერების + გამტარუნარიანობის ოპტიმიზაცია (Zero და ა.შ.). შეიძლება რეაქტიული ძრავის შეგრძნება იყოს
FSDP (PyTorch) ( PyTorch FSDP დოკუმენტები ) სასწავლო გუნდები უფასო Shards-ის პარამეტრები/გრადიენტები დიდ მოდელებს ნაკლებად საშიშს ხდის
ბიტსენდბაიტების კვანტიზაცია ( ბიტსენდბაიტები ) LLM-ის ინსტრუქტორები უფასო მცირე ბიტური წონა, მეხსიერების უზარმაზარი დაზოგვა - ხარისხი დამოკიდებულია, მაგრამ ვაიმე 😬
დისტილაცია ( ჰინტონი და სხვ., 2015 ) პროდუქტის გუნდები „დროის ხარჯი“ უფრო მცირე სტუდენტური მოდელი მემკვიდრეობით იღებს ქცევას, როგორც წესი, საუკეთესო ROI გრძელვადიანია
გასხვლა ( PyTorch-ის გასხვლის სახელმძღვანელო ) კვლევა + წარმოება უფასო აშორებს მკვდარ წონას. უკეთესად მუშაობს გადამზადებასთან ერთად
Flash Attention / შერწყმული ბირთვები ( FlashAttention ქაღალდი ) შესრულების მოყვარულები უფასო უფრო სწრაფი ყურადღება, უკეთესი მეხსიერების ქცევა. ტრანსფორმერების ნამდვილი გამარჯვება
Triton Inference Server ( დინამიური პარტირება ) ოპერაციები/ინფრასტრუქტურა უფასო წარმოება, პარტიული დამუშავება, მრავალმოდელიანი მილსადენები - საწარმოს სტილში

ფორმატირების თავისებურების აღიარება: „ფასი“ მოუწესრიგებელია, რადგან ღია კოდის გამოყენებამ შეიძლება შაბათ-კვირა გამართვა დაგიჯდეთ, რაც... ფასია. 😵💫

4) დაიწყეთ გაზომვით: პროფილი ისე, როგორც თქვენ გულისხმობთ 🔍

თუ ამ მთელი სახელმძღვანელოდან მხოლოდ ერთ რამეს აკეთებთ, გააკეთეთ ეს: სწორად გაზომეთ.

ჩემს მიერ ჩატარებული ტესტირებისას, ყველაზე დიდი „ოპტიმიზაციის გარღვევა“ ისეთი უხერხულად მარტივი რამის აღმოჩენის შედეგად მივიღე, როგორიცაა:

  • მონაცემთა ჩამტვირთავი გრაფიკულ პროცესორს აზიანებს

  • CPU-ს წინასწარი დამუშავების შეფერხება

  • მცირე ზომის პარტიები, რაც იწვევს ბირთვის გაშვების გადატვირთვას

  • ნელი ტოკენიზაცია (ტოკენიზატორები შეიძლება იყვნენ ჩუმი ბოროტმოქმედები)

  • მეხსიერების ფრაგმენტაცია ( PyTorch CUDA მეხსიერების გამანაწილებლის შენიშვნები )

  • ერთი ფენა დომინირებს გამოთვლებში

რა უნდა გაიზომოს (მინიმალური რაოდენობა)

  • ლატენტობა (p50, p95, p99) ( SRE ლატენტობის პროცენტულებზე )

  • გამტარუნარიანობა (ტოკენები/წმ, მოთხოვნები/წმ)

  • GPU-ს გამოყენება (გამოთვლა + მეხსიერება)

  • VRAM / RAM პიკები

  • ღირებულება 1 ათას ტოკენზე (ან თითო დასკვნაზე)

პრაქტიკული პროფილირების აზროვნება

  • დაწერეთ ერთი სცენარი, რომელიც გაინტერესებთ (და არა სათამაშოს მსგავსი).

  • ყველაფერი პაწაწინა „პერფორმანსების დღიურში“ ჩაინიშნეთ.
    დიახ, ეს მოსაწყენია... მაგრამ მოგვიანებით საკუთარი თავის გადაჭარბებულად გამოყენებისგან გიხსნით.

(თუ გსურთ კონკრეტული ინსტრუმენტით დაწყება: PyTorch Profiler ( torch.profiler docs ) და Nsight Systems ( NVIDIA Nsight Systems ) ყველაზე ხშირად გამოიყენება.)

5) მონაცემები + ტრენინგის ოპტიმიზაცია: ჩუმი სუპერძალა 📦🚀

ხალხი მოდელის არქიტექტურით არის გატაცებული და ივიწყებს კონვეიერს. ამასობაში, კონვეიერი ჩუმად წვავს გრაფიკული პროცესორის ნახევარს.

მარტივი მოგებები, რომლებიც სწრაფად გამოჩნდება

  • გამოიყენეთ შერეული სიზუსტე (FP16/BF16, სადაც სტაბილურია) ( PyTorch AMP / torch.amp ).
    როგორც წესი, უფრო სწრაფია, ხშირად ნორმალურიც - მაგრამ ყურადღება მიაქციეთ რიცხვით თავისებურებებს.

  • გრადიენტის დაგროვება, როდესაც პარტიის ზომა შეზღუდულია ( 🤗 აჩქარების სახელმძღვანელო )
    ინარჩუნებს ოპტიმიზაციას სტაბილურს მეხსიერების აფეთქების გარეშე.

  • გრადიენტის საკონტროლო პუნქტი ( torch.utils.checkpoint )
    მეხსიერების სანაცვლოდ გამოთვლის ფუნქციას იყენებს - უფრო დიდ კონტექსტებს შესაძლებელს ხდის.

  • ეფექტური ტოკენიზაცია ( 🤗 ტოკენიზატორები )
    ტოკენიზაცია შეიძლება მასშტაბურად გადაიქცეს შემაფერხებელ ფაქტორად. ეს არ არის მომხიბვლელი; ეს მნიშვნელოვანია.

  • მონაცემთა ჩამტვირთავის რეგულირება.
    მეტი მუშა, მიმაგრებული მეხსიერება, წინასწარი მოძიება - არასერიოზული, მაგრამ ეფექტური 😴➡️💪 ( PyTorch-ის შესრულების რეგულირების სახელმძღვანელო )

პარამეტრულად ეფექტური დახვეწა

თუ დიდი მოდელების დახვეწას ახდენთ, PEFT მეთოდებს (მაგალითად, LoRA სტილის ადაპტერებს) შეუძლიათ მნიშვნელოვნად შეამცირონ ვარჯიშის ღირებულება და ამავდროულად, გასაოცრად ძლიერი დარჩნენ ( 🤗 Transformers PEFT სახელმძღვანელო , LoRA ნაშრომი ). ეს ერთ-ერთი იმ მომენტთაგანია, სადაც ჩნდება კითხვა: „რატომ არ გავაკეთეთ ეს უფრო ადრე?“.

6) არქიტექტურის დონის ოპტიმიზაცია: მოდელის სწორი ზომა 🧩

ზოგჯერ ოპტიმიზაციის საუკეთესო გზაა… შეწყვიტო ისეთი მოდელის გამოყენება, რომელიც ამ სამუშაოსთვის ძალიან დიდია. ვიცი, მკრეხელობაა 😄.

რამდენიმე ძირითად საკითხზე გააკეთეთ ზარი:

  • გადაწყვიტეთ, გჭირდებათ სრული ზოგადი დაზვერვის ვიბრაციები თუ სპეციალისტი.

  • კონტექსტური ფანჯარა უნდა იყოს მაქსიმალურად დიდი და არა უფრო დიდი.

  • გამოიყენეთ მოცემული სამუშაოსთვის მომზადებული მოდელი (კლასიფიკაციის მოდელები კლასიფიკაციის სამუშაოებისთვის და ა.შ.).

პრაქტიკული სწორი ზომის სტრატეგიები

  • მოთხოვნების უმეტესობისთვის
    გადადით უფრო პატარა ხერხემალზე, შემდეგ კი „რთული მოთხოვნები“ გადაამისამართეთ უფრო დიდ მოდელზე.

  • გამოიყენეთ ორეტაპიანი კონფიგურაცია.
    მოდელის სწრაფი მონახაზები, მოდელის უფრო ძლიერი შემოწმება ან რედაქტირება.
    ეს ჰგავს მეგობართან ერთად წერას, რომელიც პრეტენზიულია - შემაწუხებელი, მაგრამ ეფექტური.

  • გამომავალი ტოკენების სიგრძის შემცირება.
    გამომავალი ტოკენები ფულსა და დროს მოითხოვს. თუ თქვენი მოდელი ზედმეტად იკარგება, თქვენ იხდით ზედმეტად იხეტიალისთვის.

მე მინახავს, ​​როგორ შეამცირეს გუნდებმა ხარჯები მკვეთრად შემცირებული წარმოების შემცირებით. ეს უმნიშვნელოდ ჟღერს, მაგრამ მუშაობს.

7) კომპილატორი + გრაფიკის ოპტიმიზაცია: საიდან მოდის სიჩქარე 🏎️

ეს არის ფენა, რომელიც „აიძულეთ კომპიუტერი უფრო ჭკვიანურად იმუშაოს კომპიუტერზე“.

საერთო ტექნიკა:

მარტივად რომ ვთქვათ: თქვენი მოდელი შეიძლება მათემატიკურად სწრაფი იყოს, მაგრამ ოპერაციულად ნელი. კომპილატორები ამას ნაწილობრივ ასწორებენ.

პრაქტიკული შენიშვნები (ასევე ცნობილი როგორც ნაწიბურები)

  • ეს ოპტიმიზაცია შეიძლება მგრძნობიარე იყოს მოდელის ფორმის ცვლილებების მიმართ.

  • ზოგიერთი მოდელი ძალიან აჩქარებს, ზოგი კი ძლივს იმოძრავებს.

  • ხანდახან აჩქარება და გაუგებარი შეცდომა ხდება - მაგალითად, გრემლინი შემოვიდა 🧌

მიუხედავად ამისა, როდესაც ის მუშაობს, ეს ერთ-ერთი ყველაზე სუფთა გამარჯვებაა.

8) კვანტიზაცია, გასხვლა, დისტილაცია: უფრო პატარა ზომის, ტირილის გარეშე (ძალიან ბევრი) 🪓📉

ეს ის სექციაა, რომელიც ხალხს სურს... რადგან ის თავისუფალ შესრულებას ჰგავს. შეიძლება ასეც იყოს, მაგრამ ამას ოპერაციასავით უნდა მოეკიდო.

კვანტიზაცია (დაბალი სიზუსტის წონები/აქტივაციები)

  • შესანიშნავია დასკვნის სისწრაფისა და მეხსიერებისთვის

  • რისკი: ხარისხის ვარდნა, განსაკუთრებით კიდისებრ კორპუსებზე

  • საუკეთესო პრაქტიკა: შეაფასეთ რეალურ სატესტო ნაკრებზე და არა ვიბრაციებზე

გავრცელებული არომატები, რომელთა შესახებაც გაიგებთ:

გასხვლა (პარამეტრების მოხსნა)

  • აშორებს „უმნიშვნელო“ წონას ან სტრუქტურებს ( PyTorch-ის გასხვლის სახელმძღვანელო )

  • როგორც წესი, ხარისხის აღსადგენად საჭიროა გადამზადება

  • უკეთ მუშაობს, ვიდრე ხალხს ჰგონია… როდესაც ფრთხილად კეთდება

დისტილაცია (მოსწავლე მასწავლებლისგან სწავლობს)

ეს ჩემი პირადი ფავორიტი გრძელვადიანი ბერკეტია. დისტილაციით შესაძლებელია უფრო მცირე ზომის მოდელის წარმოქმნა, რომელიც ანალოგიურად იქცევა და ის ხშირად უფრო სტაბილურია, ვიდრე ექსტრემალური კვანტიზაცია ( ცოდნის დისტილაცია ნერვულ ქსელში ).

არასრულყოფილი მეტაფორა: დისტილაცია ჰგავს რთული სუპის ფილტრში ჩასხმას და... უფრო პატარა სუპის მიღებას. სუპი ასე არ მუშაობს, მაგრამ აზრს მიხვდებით 🍲.

9) მოწოდება და დასკვნა: ნამდვილი ბრძოლის ზონა 🧯

შეგიძლიათ მოდელი „ოპტიმიზაცია“ მოახდინოთ და მაინც ცუდად წარადგინოთ. წარმართვა არის ის, სადაც შეყოვნება და ხარჯები რეალურ სახეს იღებს.

მოწოდებას მნიშვნელობა აქვს

  • პარტიებად დაყოფა
    აუმჯობესებს გამტარუნარიანობას. თუმცა, თუ ზედმეტად დაამუშავებთ, ზრდის შეყოვნებას. დააბალანსეთ. ( ტრიტონის დინამიური პარტიებად დაყოფა )

  • ქეშირება
    - ქეშირების შეკვეთა და KV-ქეშის ხელახალი გამოყენება განმეორებითი კონტექსტებისთვის შეიძლება მასიური იყოს. ( KV ქეშის ახსნა )

  • სტრიმინგის შედეგი
    მომხმარებლები თვლიან, რომ ის უფრო სწრაფია, მაშინაც კი, თუ საერთო დრო მსგავსია. აღქმას მნიშვნელობა აქვს 🙂.

  • ჟეტონების მიხედვით ზედნადები ხარჯების შემცირება.
    ზოგიერთი დასტა დამატებით სამუშაოს ასრულებს თითოეული ჟეტონით. შეამცირეთ ეს ზედნადები ხარჯები და დიდ მოგებას მიიღებთ.

ყურადღება მიაქციეთ კუდის შეყოვნებას

შესაძლოა, თქვენი საშუალო მაჩვენებელი შესანიშნავად გამოიყურებოდეს, მაშინ როცა თქვენი p99 კატასტროფაა. სამწუხაროდ, მომხმარებლები კუდის დონეზე ცხოვრობენ. ( „კუდის შეყოვნება“ და რატომ იტყუებიან საშუალო მაჩვენებლები )

10) აპარატურული ოპტიმიზაცია: მოდელის მანქანასთან შეხამება 🧰🖥️

აპარატურის ცოდნის გარეშე ოპტიმიზაცია იგივეა, რაც სარბოლო მანქანის რეგულირება საბურავების შემოწმების გარეშე. რა თქმა უნდა, ამის გაკეთება შეგიძლიათ, მაგრამ ცოტა სულელურია.

გრაფიკული პროცესორის (GPU) მოსაზრებები

  • მეხსიერების გამტარობა ხშირად შემზღუდველი ფაქტორია და არა ნედლი გამოთვლა

  • უფრო დიდი პარტიების ზომები შეიძლება დაგეხმაროთ, სანამ ისინი არ

  • ბირთვის შერწყმა და ყურადღების ოპტიმიზაცია უზარმაზარია ტრანსფორმერებისთვის ( FlashAttention: IO-aware exact attention )

პროცესორის მოსაზრებები

  • დიდი მნიშვნელობა აქვს ძაფების შერჩევას, ვექტორიზაციას და მეხსიერების ლოკალიზაციას

  • ტოკენიზაციის ხარჯები შეიძლება დომინირებდეს ( 🤗 „სწრაფი“ ტოკენიზატორები )

  • შეიძლება დაგჭირდეთ განსხვავებული კვანტიზაციის სტრატეგიები, ვიდრე GPU-ზე

Edge/მობილური მოწყობილობების მახასიათებლები

  • მეხსიერების კვალი ნომერ პირველი პრიორიტეტი ხდება

  • შეყოვნების ვარიაცია მნიშვნელოვანია, რადგან მოწყობილობები... ცვალებადია

  • მცირე, სპეციალიზებული მოდელები ხშირად აჯობებენ დიდ, ზოგად მოდელებს

11) ხარისხიანი დამცავი ღობეები: ნუ „ოპტიმიზირებთ“ საკუთარ თავს შეცდომაში 🧪

სიჩქარის ყოველ მოგებას ხარისხის შემოწმება უნდა მოჰყვეს. წინააღმდეგ შემთხვევაში, თქვენ იზეიმებთ, გააგზავნით და შემდეგ მიიღებთ შეტყობინებას, როგორიცაა: „რატომ ლაპარაკობს ასისტენტი მოულოდნელად მეკობრევით?“ 🏴☠️

პრაგმატული დამცავი ღობეები:

  • ოქროსფერი მოთხოვნები (მოთხოვნების ფიქსირებული ნაკრები, რომელსაც ყოველთვის ამოწმებთ)

  • დავალების მეტრიკა (სიზუსტე, F1, BLEU, რაც შეესაბამება)

  • ადამიანის მიერ ადგილზე შემოწმება (დიახ, სერიოზულად)

  • რეგრესიის ზღვრები („დაშვებულია არაუმეტეს X%-ისა“)

ასევე თვალყური ადევნეთ წარუმატებლობის რეჟიმებს:

  • ფორმატირების რყევა

  • უარის თქმის ქცევის ცვლილებები

  • ჰალუცინაციების სიხშირე

  • რეაგირების სიგრძის ინფლაცია

ოპტიმიზაციას შეუძლია ქცევის შეცვლა გასაკვირი გზებით. უცნაურად. გამაღიზიანებლად. პროგნოზირებადაც, უკან გადახედვისას.

12) საკონტროლო სია: როგორ ოპტიმიზაცია გავუკეთოთ ხელოვნური ინტელექტის მოდელებს ეტაპობრივად ✅🤖

თუ გსურთ, რომ AI მოდელების ოპტიმიზაციისთვის , აქ მოცემულია სამუშაო პროცესი, რომელიც ადამიანების გონზე მოყვანაში დაგეხმარებათ:

  1. წარმატების განსაზღვრა -
    აირჩიეთ 1-2 ძირითადი მეტრიკა (შეყოვნება, ღირებულება, გამტარუნარიანობა, ხარისხი).

  2. საბაზისო პროფილის რეალური სამუშაო დატვირთვების გაზომვა
    , p50/p95-ის, მეხსიერების, ხარჯების ჩაწერა. ( PyTorch Profiler )

  3. მილსადენის შეფერხებების გამოსწორება.
    მონაცემთა ჩატვირთვა, ტოკენიზაცია, წინასწარი დამუშავება, პარტიებად დაყოფა.

  4. დაბალი რისკის მქონე გამოთვლითი მოგებების გამოყენება.
    შერეული სიზუსტე, ბირთვის ოპტიმიზაცია, უკეთესი პარტირება.

  5. სცადეთ კომპილატორის/გაშვების დროის ოპტიმიზაცია.
    გრაფის აღება, ინფერენციის გაშვების დრო, ოპერატორის შერწყმა. ( torch.compile სახელმძღვანელო , ONNX Runtime დოკუმენტაცია )

  6. მოდელის ღირებულების შემცირება
    . ფრთხილად კვანტიზაცია, თუ შესაძლებელია, დისტილაცია და საჭიროების შემთხვევაში გასხვლა.

  7. სერვისების რეგულირება:
    ქეშირება, პარალელუცია, დატვირთვის ტესტირება, კუდის შეყოვნების გამოსწორება.

  8. ხარისხის შემოწმება.
    ჩაატარეთ რეგრესიული ტესტები და შეადარეთ შედეგები გვერდიგვერდ.

  9. იტერაცია -
    მცირე ცვლილებები, მკაფიო შენიშვნები, გამეორება. არასანახაობრივი - ეფექტური.

და დიახ, ეს მაინც „ როგორ ოპტიმიზაცია გავუკეთოთ ხელოვნური ინტელექტის მოდელებს“, მაშინაც კი, თუ უფრო „როგორ შევაჩეროთ ჯოხებზე ფეხის დაბიჯება“-ს ჰგავს. იგივეა.

13) გავრცელებული შეცდომები (რომ არ გაიმეოროთ ისინი ჩვენსავით) 🙃

  • ოპტიმიზაცია გაზომვამდე
    . დროს დაკარგავთ. შემდეგ კი არასწორ რამეს თავდაჯერებულად ოპტიმიზაციას მოახდენთ…

  • ერთი საორიენტაციო მაჩვენებლის ძიება
    საორიენტაციო მაჩვენებლებს გამოტოვება გულისხმობს. თქვენი სამუშაო დატვირთვა სიმართლეა.

  • მეხსიერების იგნორირება
    მეხსიერების პრობლემები იწვევს შენელებებს, ავარიებს და რხევას. ( CUDA მეხსიერების გამოყენების გაგება PyTorch-ში )

  • ნაადრევად ზედმეტად კვანტიზაცია.
    დაბალი ბიტის კვანტიზაცია შეიძლება საოცარი იყოს, მაგრამ ჯერ უფრო უსაფრთხო ნაბიჯებით დაიწყეთ.

  • უკან დაბრუნების გეგმა არ არსებობს.
    თუ სწრაფად ვერ დაუბრუნდებით პარამეტრებს, ყოველი განლაგება სტრესული გახდება. სტრესი შეცდომებს წარმოქმნის.

დასკვნითი შენიშვნები: ოპტიმიზაციის ადამიანური გზა 😌⚡

ხელოვნური ინტელექტის მოდელების ოპტიმიზაცია ერთი ხრიკი არ არის. ეს მრავალშრიანი პროცესია: გაზომეთ, შეასწორეთ პროცესორი, გამოიყენეთ კომპილატორები და გაშვების დრო, დაარეგულირეთ მომსახურება და შემდეგ საჭიროების შემთხვევაში შეამცირეთ მოდელი კვანტიზაციით ან დისტილაციით. გააკეთეთ ეს ეტაპობრივად, შეინარჩუნეთ ხარისხის დამცავი ბარიერები და ნუ ენდობით „უფრო სწრაფად გრძნობას“, როგორც მეტრიკას (თქვენი გრძნობები სასიამოვნოა, თქვენი გრძნობები არ არის პროფილერი).

თუ გსურთ ყველაზე მოკლე გატანა:

  • ჯერ გაზომე 🔍

  • შემდეგ მილსადენის ოპტიმიზაცია 🧵

  • შემდეგ მოდელის ოპტიმიზაცია 🧠

  • შემდეგ ოპტიმიზაცია გაუკეთეთ მომსახურებას 🏗️

  • ყოველთვის შეამოწმეთ ხარისხი ✅

და თუ ეს დაგეხმარებათ, შეახსენეთ საკუთარ თავს: მიზანი არ არის „იდეალური მოდელი“. მიზანია ისეთი მოდელი, რომელიც იქნება სწრაფი, ხელმისაწვდომი და საკმარისად საიმედო, რომ ღამით ძილი შეძლოთ... თითქმის ყველა ღამეს 😴.

ხშირად დასმული კითხვები

რას ნიშნავს ხელოვნური ინტელექტის მოდელის ოპტიმიზაცია პრაქტიკაში

„ოპტიმიზაცია“, როგორც წესი, ერთი ძირითადი შეზღუდვის გაუმჯობესებას ნიშნავს: შეყოვნება, ღირებულება, მეხსიერების დატვირთვა, სიზუსტე, სტაბილურობა ან გამტარუნარიანობა. რთული ნაწილი კომპრომისზე წასვლაა - ერთი სფეროს წინ წამოწევამ შეიძლება მეორეზე უარყოფითად იმოქმედოს. პრაქტიკული მიდგომაა მკაფიო სამიზნის (მაგალითად, p95 შეყოვნება ან ხარისხის მიღწევის დრო) არჩევა და მისკენ ოპტიმიზაცია. სამიზნის გარეშე, ადვილია „გაუმჯობესება“ და მაინც წაგება.

როგორ ოპტიმიზაცია გავუკეთოთ ხელოვნური ინტელექტის მოდელებს ხარისხის შეუმჩნევლად შემცირების გარეშე

სიჩქარის ან ღირებულების ყოველი ცვლილება პოტენციურ ჩუმ რეგრესიად აღიქვით. გამოიყენეთ დამცავი ბარიერები, როგორიცაა ოქროსფერი მინიშნებები, დავალებების მეტრიკა და სწრაფი ადამიანური შემოწმებები. დააწესეთ მისაღები ხარისხის გადახრის მკაფიო ზღვარი და შეადარეთ შედეგები ერთმანეთის გვერდიგვერდ. ეს ხელს შეუშლის „უფრო სწრაფია“-ს გადაქცევაში „რატომ გახდა უცებ უცნაურად წარმოებაში?“-ად გაგზავნის შემდეგ.

რა უნდა გაზომოთ ოპტიმიზაციის დაწყებამდე

დაიწყეთ შეყოვნების პროცენტული მაჩვენებლებით (p50, p95, p99), გამტარუნარიანობით (ტოკენები/წამში ან მოთხოვნები/წამში), გრაფიკული პროცესორის გამოყენებით და პიკური VRAM/RAM-ით. თვალყური ადევნეთ ხარჯებს თითო დასკვნაზე ან 1 ათას ტოკენზე, თუ ღირებულება შეზღუდვაა. შეადგინეთ თქვენს მიერ წარმოდგენილი რეალური სცენარის პროფილი და არა სათამაშო მინიშნება. პატარა „შესრულების ჟურნალის“ წარმოება დაგეხმარებათ თავიდან აიცილოთ გამოცნობა და შეცდომების გამეორება.

სწრაფი, დაბალი რისკის მქონე გამარჯვებები ვარჯიშის შესრულებისთვის

შერეული სიზუსტე (FP16/BF16) ხშირად ყველაზე სწრაფი პირველი ბერკეტია, მაგრამ ყურადღება მიაქციეთ რიცხვით თავისებურებებს. თუ პარტიის ზომა შეზღუდულია, გრადიენტის დაგროვებას შეუძლია ოპტიმიზაციის სტაბილიზაცია მეხსიერების დატვირთვის გარეშე. გრადიენტის საკონტროლო პუნქტები დამატებით გამოთვლას ცვლის მეხსიერების შემცირების სანაცვლოდ, რაც უფრო დიდ კონტექსტებს ქმნის. არ უგულებელყოთ ტოკენიზაცია და მონაცემთა ჩატვირთვის რეგულირება - მათ შეუძლიათ ჩუმად დათრგუნონ GPU.

როდის გამოვიყენოთ torch.compile, ONNX Runtime ან TensorRT

ეს ხელსაწყოები მიზნად ისახავს ოპერაციულ ზედნადებ ხარჯებს: გრაფიკის აღებას, ბირთვის შერწყმას და გაშვების დროს გრაფიკის ოპტიმიზაციას. მათ შეუძლიათ სუფთა ინფერენციის დაჩქარების უზრუნველყოფა, მაგრამ შედეგები განსხვავდება მოდელის ფორმისა და აპარატურის მიხედვით. ზოგიერთი დაყენება ჯადოსნურად ჟღერს; სხვები ძლივს მოძრაობენ. ველით მგრძნობელობას ფორმის ცვლილებების მიმართ და ზოგჯერ „გრემლინის“ შეცდომებს - გაზომეთ „ადრე“ და შემდეგ თქვენს რეალურ სამუშაო დატვირთვაზე.

ღირს თუ არა კვანტიზაცია და როგორ ავიცილოთ თავიდან ზედმეტად შორს წასვლა

კვანტიზაციამ შეიძლება შეამციროს მეხსიერება და დააჩქაროს დასკვნების გამოტანა, განსაკუთრებით INT8-ის შემთხვევაში, თუმცა ხარისხი შეიძლება უარეს შემთხვევაშიც კი დავარდეს. უფრო დაბალი ბიტის ვარიანტები (მაგალითად, INT4/k-bit) უფრო დიდ დანაზოგს იძლევა მაღალი რისკის გათვალისწინებით. ყველაზე უსაფრთხო ჩვევაა რეალურ სატესტო ნაკრებზე შეფასება და გამომავალი მონაცემების შედარება და არა ინტუიციით. ჯერ უფრო უსაფრთხო ნაბიჯებით დაიწყეთ და შემდეგ, საჭიროების შემთხვევაში, უფრო დაბალი სიზუსტით გადადით.

მოდელის ზომის შემცირებისთვის გასხვლასა და დისტილაციას შორის განსხვავება

გასხვლა „მკვდარი წონის“ პარამეტრებს აშორებს და ხშირად საჭიროებს გადამზადებას ხარისხის აღსადგენად, განსაკუთრებით მაშინ, როდესაც ეს აგრესიულად ხორციელდება. დისტილაცია ასწავლის უფრო პატარა მოსწავლის მოდელს, რომ მიბაძოს უფრო დიდი მასწავლებლის ქცევას და ეს შეიძლება იყოს უფრო ძლიერი გრძელვადიანი ინვესტიციის ანაზღაურება, ვიდრე ექსტრემალური კვანტიზაცია. თუ გსურთ უფრო პატარა მოდელი, რომელიც მსგავსად იქცევა და სტაბილურად რჩება, დისტილაცია ხშირად უფრო სუფთა გზაა.

როგორ შევამციროთ დასკვნის ღირებულება და შეყოვნება მომსახურების გაუმჯობესების გზით

ოპტიმიზაცია ხელშესახები ხდება სერვისში: პაკეტური დახარისხება ზრდის გამტარუნარიანობას, მაგრამ თუ ზედმეტად გამოიყენება, შეიძლება შეამციროს შეყოვნება, ამიტომ ფრთხილად დაარეგულირეთ. ქეშირება (სწრაფი ქეშირება და KV-ქეშის ხელახალი გამოყენება) შეიძლება მასშტაბური იყოს, როდესაც კონტექსტები მეორდება. ნაკადის გამომავალი აუმჯობესებს აღქმულ სიჩქარეს, მაშინაც კი, თუ საერთო დრო მსგავსია. ასევე, ყურადღება მიაქციეთ თქვენს სტეკში ტოკენების ოვერჰედს - თითო ტოკენზე მცირე სამუშაო სწრაფად გროვდება.

რატომ არის კუდის შეყოვნება ასეთი მნიშვნელოვანი ხელოვნური ინტელექტის მოდელების ოპტიმიზაციისას?

საშუალო მაჩვენებლები შეიძლება შესანიშნავად გამოიყურებოდეს, მაშინ როცა p99 კატასტროფაა და მომხმარებლები, როგორც წესი, კუდის შეფერხებას აგრძელებენ. კუდის შეყოვნება ხშირად გამოწვეულია რყევით: მეხსიერების ფრაგმენტაციით, პროცესორის წინასწარი დამუშავების პიკებით, ტოკენიზაციის შენელებით ან ცუდი პაკეტური დამუშავებით. სწორედ ამიტომ, სახელმძღვანელო ხაზს უსვამს პროცენტულებსა და რეალურ სამუშაო დატვირთვას. თუ მხოლოდ p50-ს ოპტიმიზაციას გაუკეთებთ, მაინც შეგიძლიათ შესთავაზოთ გამოცდილება, რომელიც „შემთხვევით ნელა იგრძნობა“

ცნობები

  1. Amazon Web Services (AWS) - AWS CloudWatch-ის პროცენტული მაჩვენებლები (სტატისტიკური განმარტებები) - docs.aws.amazon.com

  2. Google - მასშტაბის კუდი (კუდის შეყოვნების საუკეთესო პრაქტიკა) - sre.google

  3. Google - მომსახურების დონის მიზნები (SRE წიგნი) - შეყოვნების პროცენტული მაჩვენებლები - sre.google

  4. PyTorch - torch.compile - docs.pytorch.org

  5. PyTorch - FullyShardedDataParallel (FSDP) - docs.pytorch.org

  6. PyTorch - PyTorch Profiler - docs.pytorch.org

  7. PyTorch - CUDA სემანტიკა: მეხსიერების მართვა (CUDA მეხსიერების გამანაწილებლის შენიშვნები) - docs.pytorch.org

  8. PyTorch - ავტომატური შერეული სიზუსტე (torch.amp / AMP) - docs.pytorch.org

  9. PyTorch - torch.utils.checkpoint - docs.pytorch.org

  10. PyTorch - შესრულების რეგულირების სახელმძღვანელო - docs.pytorch.org

  11. PyTorch - გასხვლის ინსტრუქცია - docs.pytorch.org

  12. PyTorch - CUDA მეხსიერების გამოყენების გაგება PyTorch-ში - docs.pytorch.org

  13. PyTorch - torch.compile-ის სახელმძღვანელო / მიმოხილვა - docs.pytorch.org

  14. ONNX Runtime - ONNX Runtime დოკუმენტაცია - onnxruntime.ai

  15. NVIDIA - TensorRT დოკუმენტაცია - docs.nvidia.com

  16. NVIDIA - TensorRT კვანტიზირებული ტიპები - docs.nvidia.com

  17. NVIDIA - Nsight Systems - developer.nvidia.com

  18. NVIDIA - Triton Inference Server - დინამიური პარტირება - docs.nvidia.com

  19. DeepSpeed ​​- ZeRO Stage 3 დოკუმენტაცია - deepspeed.readthedocs.io

  20. bitsandbytes (bitsandbytes-foundation) - bitsandbytes - github.com

  21. ჩახუტება სახეზე - აჩქარება: გრადიენტის დაგროვების სახელმძღვანელო - huggingface.co

  22. ჩახუტებადი სახე - ტოკენიზატორების დოკუმენტაცია - huggingface.co

  23. ჩახუტებადი სახე - ტრანსფორმერები: PEFT სახელმძღვანელო - huggingface.co

  24. Hugging Face - Transformers: KV cache-ის ახსნა - huggingface.co

  25. Hugging Face - ტრანსფორმერები: „სწრაფი“ ტოკენიზატორები (ტოკენიზატორების კლასები) - huggingface.co

  26. arXiv - ცოდნის დისტილაცია ნეირონულ ქსელში (ჰინტონი და სხვ., 2015) - arxiv.org

  27. arXiv - LoRA: დიდი ენობრივი მოდელების დაბალი რანგის ადაპტაცია - arxiv.org

  28. arXiv - FlashAttention: სწრაფი და მეხსიერების ეფექტური, ზუსტი ყურადღება IO-Awareness-ის გამოყენებით - arxiv.org

იპოვეთ უახლესი ხელოვნური ინტელექტი ოფიციალურ ხელოვნური ინტელექტის ასისტენტების მაღაზიაში

ჩვენს შესახებ

ბლოგზე დაბრუნება