Գնահատել նախագիծը
← Բոլոր հրապարակումները

Ինչպես արագացնել LLM-ները production-ում

Այս հոդվածում անդրադարձանք LLM-ները արդյունավետ տեղակայելու, տարբերակավորելու և մոնիտորինգի ենթարկելու համար նախատեսված մի շարք հիանալի գործիքների և գրադարանների։

8 րոպե
Մեքենայական ուսուցումLLMՉատբոտերTriton

Մեծ լեզվական մոդելները (LLM) production համակարգերում ներդնելը բազմաթիվ դժվարություններ է բերում, և նեղ տեղերը գտնելը առանցքային է դրանց արտադրողականությունը կարգավորելու համար։ LLM-ները production-ում աշխատեցնելիս բնորոշ նեղ տեղերն են՝

  1. Latency (հապաղում)։ LLM-ները պատասխանը ստեղծում են մեկ token-ով՝ ըստ կառուցվածքի, ուստի երկար prompt-երի և երկար ստեղծվող պատասխանների դեպքում կանխատեսումները ավելի երկար են տևում։
  2. Throughput (թողունակություն)։ Ամեն վայրկյան ձեր սերվերին հասնող հարցումների մեծ քանակը՝ բարձր latency-ի հետ համատեղ, կարող է սերվերը սառեցնել կամ բազմաթիվ timeout-ներ առաջացնել։ Սերվերի throughput-ը միայն փոքր լրացուցիչ ծախսով բարձրացնելու հիմնական եղանակը հարցումները միավորելն է, կամ ավելի լավ՝ inflight batching օգտագործելը։
  3. Հիշողության պահանջներ։ Դրանք ուղղակիորեն կախված են մոդելի չափից և prompt-ի երկարությունից։ Ավելի մեծ մոդելը և ավելի երկար prompt-ը երկուսն էլ նշանակում են ավելի շատ VRAM։
  4. Էներգասպառում։ Ավելի մեծ մոդելները՝ ավելի երկար prompt-երով և արդյունքներով, պահանջում են ավելի շատ հաշվարկ և ավելի երկար են կատարում inference, ուստի ավելի շատ էներգիա են սպառում։ Խոշոր մասշտաբի production համակարգերում սա կարող է լինել խոշոր ծախս։
  5. Մասշտաբավորելիություն։ LLM-ները պահանջում են թանկ բարձրակարգ մեքենաներ։ Համակարգը մասշտաբավորելու համար ավելի շատ մեքենաներ ավելացնելը շատ թանկ է, ուստի էական է մեկ մեքենայից առավելագույն արտադրողականություն քամելը։
  6. Մոդելի թարմացումներ և տարբերակավորում։

Այս նեղ տեղերի հաղթահարումը պահանջում է սարքավորումների օպտիմալացման, մոդելի ճարտարապետության կարգավորման և արդյունավետ տեղակայման ռազմավարությունների համադրություն։ LLM-ները տեղակայելիս նաև էական է հաշվի առնել production միջավայրի հատուկ պահանջներն ու սահմանափակումները։ Ստորև անդրադառնում եմ այս մարտահրավերների հետ գործ ունենալու ամենակարևոր կողմերին։

Նեղ տեղը գտնելը

Տեղակայված մոդելի արտադրողականության բարելավումը միշտ պետք է սկսվի խնդիրը ճշգրիտ սահմանելուց։ Ինչպես վերևում թվարկված է, կարող ենք բախվել բազմաթիվ մարտահրավերների, ուստի նախ պետք է պարզել, թե դրանցից որոնք են մեզ համար ամենակարևորը։ Եթե առաջին խոչընդոտը մոդելը GPU-ի վրա տեղավորելն է, հիշողության օպտիմալացումը ակնհայտորեն այն է, ինչից սկսում ենք։ Տարբերակները ներառում են մոդելի quantization float16 կամ float8 ձևաչափով, կամ մոդելի շերտերը inference-ի ժամանակ մեկ-մեկ բեռնելը։ Երբ շերտի արդյունքը հաշվարկվել է, այդ շերտը հեռացվում է GPU-ից, և հաջորդը CPU-ից փոխանցվում է GPU։ Այսպես կարելի է ձեր համակարգում աշխատեցնել ցանկացած չափի մոդել, պայմանով որ ամենամեծ շերտը տեղավորվի ձեր GPU-ում։ Այս հնարավորությունը հասանելի է accelerate գրադարանում։

Երբ մոդելը գործարկված է, կարող ենք անցնել մյուս մարտահրավերներին։ Եթե համակարգն ունի ընդամենը մի քանի օգտատեր, կամ շատ օգտատերեր և բարձր throughput, բայց պատասխանները դանդաղ են գալիս, գուցե ուզենանք ավելացնել պատասխանի streaming կամ կրճատել inference-ի ժամանակը։ Դա անելու եղանակներից են Flash-Attention շերտերը, max beam width-ի սահմանումը, մուտքային padding-ի հեռացումը, instance normalization-ի փոխարեն root-mean-square-normalization շերտերի (RMS norm) օգտագործումը, GEneral Matrix to Matrix Multiplication-ի (GEMM) օգտագործումը կամ GatedMLP շերտերի հորիզոնական միավորումը։ Quantization-ը նույնպես կարող է արագացնել inference-ը, բայց միայն երբ օգտագործվում են quantized kernel-ներ։ Quantization մեթոդների մեծ մասը պարզապես փոքրացնում են մոդելը՝ առանց inference-ը արագացնելու։ Նկատի ունեցեք նաև, որ ոչ բոլոր GPU ճարտարապետություններն են աջակցում ճշգրտության բոլոր տեսակներին, ուստի quantization-ի վերաբերյալ ընտրությունները պետք է հիմնված լինեն թիրախային GPU ճարտարապետության հնարավորությունների վրա։ Ամենահայտնի NVIDIA GPU-ների համար ճշգրտության աջակցության մատրիցը հասանելի է [այստեղ](https://github.com/NVIDIA/TensorRT-LLM#:~:text=may, however, apply.-,Precision,-Various numerical precisions)։

Եթե latency-ն արդեն ցածր է, բայց խնդիրը throughput-ն է, այսինքն՝ օգտատերերի այն քանակը, որին համակարգը կարող է միաժամանակ սպասարկել, կարող ենք իրականացնել cellular batching, iteration-level scheduling կամ paged attention։ Առաջին երկուսը թույլ են տալիս նոր ժամանած հարցումներին միանալ, իսկ ավարտված հարցումներին վերադարձվել token-ների ստեղծման ցիկլի յուրաքանչյուր իտերացիայում։ Paged attention-ը GPU հիշողության կառավարման խելացի սխեմա է, որը հիշողության մասնատումը պահում է նվազագույն, միաժամանակ արագացնելով inference-ը՝ KV-ն քեշավորելով։

Ինչ խնդիր էլ լինի, ես սիրում եմ սկսել կոդի պրոֆիլավորումից, որովհետև համակարգի վրա կարող են ազդել այլ տարօրինակ բաներ։ Օրինակ՝ մի քանի ամիս առաջ LLM-ի որոշ կոդ պրոֆիլավորելիս հայտնաբերեցի, որ այն փորձում էր մոդելը բեռնել bfloat16 ճշգրտությամբ Tesla T4-ի վրա, որը bfloat16-ի աջակցություն չունի, ուստի անցավ float32-ի և օգտագործեց x2 անգամ ավելի շատ հիշողություն։ Նույնիսկ այնքան պարզ բան, ինչպիսին CUDA-ն 11.7-ից 12.3 թարմացնելն է, կարող է մոդելը 20%-ով արագացնել։

TensorRT-LLM

Սա հիանալի գործիք է LLM-ների օպտիմալացման համար, և այն իրականացնում է վերևում թվարկված inference-ի արագության և հիշողության օգտագործման բոլոր օպտիմալացումները։ TensorRT-LLM-ից օգտվել սկսելու համար հետևեք պաշտոնական տեղադրման ուղեցույցին իր GitHub պահոցում։ Մոդելը TRT-LLM-ով արագացնելու առանցքային քայլը դրա փոխակերպումն է։ TRT-LLM 8.0-ից ցածր տարբերակների համար փոխակերպումը կատարվում է հետևյալ հրամանով՝

Կոդի հատված 1. Building a TensorRT engine file from a given model. Version 1.

Նոր տարբերակներում engine-ի ստեղծումը 2 քայլ է պահանջում՝

Կոդի հատված 2. Building a TensorRT engine file from a given model. Version 2, part 1.

Կոդի հատված 3. Building a TensorRT engine file from a given model. Version 2, part 2.

Երբ engine ֆայլերը կառուցված են, կարող եք inference թեստ գործարկել _python3 /trtllm/examples/run.py սկրիպտով։

Inflight batching

Naive batching մոտեցման դեպքում նախորդ հարցումները կա՛մ սպասում են հաջորդներին, կա՛մ մուտքային հարցումները պահվում են, մինչև նախորդներն ավարտվեն, ինչը երկար հերթային հապաղումներ է առաջացնում։ TensorRT-LLM-ը BatchManager-ի միջոցով ապահովում է in-flight batching՝ ըստ հարցման։ Մոդելի փոխակերպման ժամանակ _-use_inflightbatching դրոշակի սահմանումը թույլ է տալիս մոդելին նոր հարցումներ ավելացնել արդեն մշակվող հարցումների խմբաքանակին։ Նախորդ հարցման ավարտին սպասելու փոխարեն նոր հարցումը կարող է միանալ խմբաքանակին իտերացիայի մակարդակով, այսինքն՝ երբ ընթացիկ իտերացիայի նոր token-ը ստեղծվել է։ Սա զգալիորեն բարձրացնում է throughput-ը՝ ընդամենը փոքր լրացուցիչ հաշվարկի և հիշողության գնով։

Paged Attention

Inflight batching-ը բարձրացնում է մոդելի throughput-ը, բայց դրա բերած մեծ batch size-ը նաև մեծացնում է հիշողության օգտագործումը։ Առկա համակարգերը դժվարանում են, քանի որ յուրաքանչյուր հարցման key-value cache-ի (KV cache) համար վերապահված հիշողությունը մեծ է, և դրա չափը դինամիկ կերպով փոխվում է։ Այս հիշողության վատ կառավարումը կարող է դրա մեծ մասը վատնել մասնատման և անհարկի կրկնօրինակման պատճառով, ինչը վերջնական հաշվով սահմանափակում է batch size-ը, որը համակարգը կարող է արդյունավետ մշակել։ Ահա այստեղ է գործի անցնում Paged Attention-ը՝ ալգորիթմ, որը մոդելավորված է օպերացիոն համակարգերում օգտագործվող դասական վիրտուալ հիշողության և paging տեխնիկաների վրա։ KV cache-ը որպես հիշողության մեկ անընդմեջ բլոկ վերապահելու փոխարեն այն բաժանում է ավելի փոքր բլոկների, որոնք պարտադիր չէ անընդմեջ լինեն։ Դրա վրա ավելացվում է տրամաբանություն KV cache բլոկները հարցումների միջև և հարցումների ներսում կիսելու համար։ Արդյունքը LLM սպասարկման համակարգ է՝ գրեթե առանց վատնված KV cache հիշողության և ճկուն KV cache կիսմամբ հարցումների ներսում և միջև։ TensorRT inflight batching-ի դեպքում paged attention-ն էլ պետք է միացված լինի։ PaggedAttention-ը միացվում է _–paged_kvcache դրոշակով։ Նկատի ունեցեք, որ TensorRT իրականացման մեջ paged KV cache-ը հատկացվում է նախապես, այլ ոչ թե ըստ պահանջի, ինչպես նկարագրված է հոդվածում։ Արդյունքում մեզ պետք է մոտ 60%-ով ավելի շատ VRAM հիշողություն, քան հենց մոդելն է պահանջում։ Թե ճիշտ որքան հիշողություն է վերապահվում KV cache-ի համար, կախված է batch size-ից, մուտքային/ելքային prompt-ների առավելագույն երկարություններից և, ի վերջո, ստեղծվող token-ների առավելագույն քանակից։

Triton

Triton-ը մոդելների սպասարկման գործիք է։ Այն TensorRT-LLM-ի հետ ինտեգրվում է TensorRT-LLM-backend-ի միջոցով։ TensorRT-LLM-ը Triton-ով տեղակայելիս կոնկրետ տարբերակները պետք է համընկնեն։ Օրինակ՝ Triton 24.01 սերվերի կոնտեյների պատկերը տրվում է TensorRT-LLM 7.1-ով։ Մոդելները TensorRT engine-ի մեջ կոդի այլ տարբերակով կոմպիլյացնելը inference-ի ժամանակ սխալներ կառաջացնի։ Արդեն TenroRT-LLM-backend ներառող պատրաստի docker պատկերները կարող են շատ հարմար լինել։ Բոլոր հասանելի պատկերները կգտնեք Triton NGC էջում։

Մոդելը սպասարկելու համար պետք է կարգավորել 4 դիրեկտորիա, որոնք հետևում են Նկար 1-ում ցույց տրված դասավորությանը։

Figure 1. Directory layout for the Triton inference server.

  • Preprocessing։ Այս թղթապանակը պարունակում է սկրիպտներ և հրահանգներ՝ հարցումները մոդելին հասնելուց առաջ պատրաստելու համար։
  • Tensrrt_llm։ Այս թղթապանակը պարունակում է մոդելի engine ֆայլերը, մոդելի կոնֆիգուրացիոն ֆայլերը և մուտք-ելք տվյալների կառուցվածքներն ու տիպերը նկարագրող կոնֆիգուրացիոն ֆայլերը։
  • Postprocessing։ Այս թղթապանակը պարունակում է սկրիպտներ և հրահանգներ՝ մոդելի արդյունքի հետմշակման համար։
  • Ensemble։ Այս թղթապանակը պարունակում է սկրիպտներ և հրահանգներ, որոնք համակարգում են նախամշակումը, մոդելի inference-ը և հետմշակումը։ Այն կարող է նաև անհրաժեշտության դեպքում կատարել այլ գործողություններ, օրինակ՝ երկու մոդել հերթով աշխատեցնել։

Pbtxt ֆայլերը նկարագրում են մոդելի մուտքերը/ելքերը, դրանց ձևն ու տիպը և, որտեղ կիրառելի է, որոշ հիպերպարամետրեր։ Մյուս հիպերպարամետրերի շարքում batch size-ը և decoupled բուլյան արժեքը պարտադիր են։ Երբ վերջինը սահմանված է False, մոդելը մեկ հարցման դիմաց վերադարձնում է ճիշտ մեկ պատասխան։

Յուրաքանչյուր ենթաթղթապանակի անունը սկսվում է թվով, որը նշում է մոդելի/կոդի տարբերակը։ Թղթապանակի ներսում կարելի է դնել մոդելի checkpoint կամ Python սկրիպտ։ Python սկրիպտը կատարվում է ըստ ensemble ռազմավարության, իսկ մոդելի checkpoint-ը սերվերն ավտոմատ բեռնում է։ Triton-ի մոդելների պահոցի մասին ավելին կարող եք գտնել այստեղ։

Triton-ը ներառում է նաև օգտակար model analyzer, որը կարող է առաջարկել Triton սերվերի պարամետրեր և սարքավորումների կազմաձևում՝ լավագույն throughput-ի և ամենացածր latency-ի համար։ Օրինակ՝ այն կարող է առաջարկել օպտիմալ batch size կամ instance-ների քանակ։

Երբ Triton մոդելների պահոցը պատրաստ է, Triton սերվերը կարող եք գործարկել հետևյալով՝

Կոդի հատված 4. Starting the triton server.

Կամ docker կոնտեյների օգտագործման դեպքում՝

Կոդի հատված 5. Starting a triton server with docker.

Ամփոփում

Այս հոդվածում անդրադարձանք LLM-ները արդյունավետ տեղակայելու, տարբերակավորելու և մոնիտորինգի ենթարկելու համար նախատեսված մի շարք հիանալի գործիքների և գրադարանների։ Իսկ եթե ձեր մոդելը արդյունավետ դարձնելը դեռ դժվար է, մի տատանվեք կապ հաստատել մեզ հետ։ Մենք սիրով կօգնենք։