Հիշողության օպտիմիզացում մեծ լեզուների մոդելի եզրակացության և ճշգրտման համար

Լեզուների խոշոր մոդելները (LLM), ինչպիսիք են GPT-4-ը, Bloom-ը և LLaMA-ն, հասել են ուշագրավ հնարավորությունների՝ չափելով մինչև միլիարդավոր պարամետրեր: Այնուամենայնիվ, եզրակացության կամ ճշգրտման համար այս զանգվածային մոդելների տեղակայումը դժվար է հիշողության ահռելի պահանջների պատճառով: Այս տեխնիկական բլոգում մենք կուսումնասիրենք LLM-ի եզրակացության ընթացքում հիշողության սպառումը գնահատելու և օպտիմալացնելու տեխնիկան և տարբեր ապարատային կարգավորումների վրա ճշգրտում:

Հասկանալով հիշողության պահանջները

LLM-ի բեռնման համար պահանջվող հիշողությունը հիմնականում որոշվում է պարամետրերի քանակով և պարամետրերը պահելու համար օգտագործվող թվային ճշգրտությամբ: Մի պարզ կանոն.

• X միլիարդ պարամետրերով մոդելի բեռնումը մոտավորապես պահանջում է 4X ԳԲ VRAM-ի մեջ 32-bit լողացող ճշգրտություն
• X միլիարդ պարամետրերով մոդելի բեռնումը մոտավորապես պահանջում է 2X ԳԲ VRAM-ի մեջ 16-bit bfloat16/float16 ճշգրտություն

Օրինակ, 175B պարամետրի GPT-3 մոդելը բեռնելու համար կպահանջվի մոտավորապես 350 ԳԲ VRAM bfloat16 ճշգրտությամբ: Այսօրվա դրությամբ խոշորագույն առևտրային պրոցեսորները, ինչպիսիք են NVIDIA A100-ը և H100-ը, առաջարկում են ընդամենը 80 ԳԲ VRAM, ինչը պահանջում է տենզորի զուգահեռություն և մոդելների զուգահեռության տեխնիկա:

Եզրակացության ժամանակ հիշողության հետքը գերակշռում է մոդելի պարամետրերով և արտադրված ժամանակավոր ակտիվացման տենսորներով: Եզրակացության ընթացքում հիշողության առավելագույն օգտագործման բարձր մակարդակի գնահատականը մոդելի պարամետրերի բեռնման և ակտիվացման հիշողության համար պահանջվող հիշողության գումարն է:

Եզրակացությունների հիշողության քանակականացում

Եկեք քանակականացնենք հիշողության պահանջները եզրակացության համար՝ օգտագործելով OctoCode մոդելը, որն ունի շուրջ 15 միլիարդ պարամետր bfloat16 ձևաչափով (~ 31 ԳԲ): Մենք կօգտագործենք Տրանսֆորմատորների գրադարան մոդելը բեռնելու և տեքստ ստեղծելու համար.

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
import torch
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder",
torch_dtype=torch.bfloat16,
device_map="auto",
pad_token_id=0)
tokenizer = AutoTokenizer.from_pretrained("bigcode/octocoder")
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
prompt = "Question: Please write a Python function to convert bytes to gigabytes.\n\nAnswer:"
result = pipe(prompt, max_new_tokens=60)[0]["generated_text"][len(prompt):]
def bytes_to_gigabytes(bytes):
return bytes / 1024 / 1024 / 1024
bytes_to_gigabytes(torch.cuda.max_memory_allocated())

Արդյունք:

GPU-ի հիշողության առավելագույն օգտագործումը կազմում է մոտ 29 ԳԲ, ինչը համընկնում է մոդելի պարամետրերը bfloat31 ձևաչափով բեռնելու համար 16 ԳԲ մեր գնահատականի հետ:

Եզրակացությունների հիշողության օպտիմիզացում քվանտացման միջոցով

Թեև bfloat16-ը սովորական ճշգրտությունն է, որն օգտագործվում է LLM-ների վերապատրաստման համար, հետազոտողները պարզել են, որ մոդելի կշիռների քանակականացումը ավելի ցածր ճշգրիտ տվյալների տեսակների համար, ինչպիսիք են 8-բիթանոց ամբողջ թվերը (int8) կամ 4-բիթանոց ամբողջ թվերը, կարող է զգալիորեն նվազեցնել հիշողության օգտագործումը նվազագույն ճշգրտության կորստով եզրակացության առաջադրանքների համար: տեքստի ստեղծում:

Եկեք տեսնենք OctoCode մոդելի 8-բիթանոց և 4-բիթանոց քվանտացումից հիշողության խնայողությունները.

</div>
# 8-bit quantization
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder", load_in_8bit=True, 
pad_token_id=0)
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
result = pipe(prompt, max_new_tokens=60)[0]["generated_text"][len(prompt):]
bytes_to_gigabytes(torch.cuda.max_memory_allocated())</pre>

Արդյունք:

# 4-bit quantization
model = AutoModelForCausalLM.from_pretrained("bigcode/octocoder", load_in_4bit=True,
low_cpu_mem_usage=True, pad_token_id=0)
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
result = pipe(prompt, max_new_tokens=60)[0]["generated_text"][len(prompt):]
bytes_to_gigabytes(torch.cuda.max_memory_allocated())

Արդյունք:

8-բիթանոց քվանտացման դեպքում հիշողության պահանջը 31 ԳԲ-ից նվազում է մինչև 15 ԳԲ, մինչդեռ 4-բիթանոց քվանտացումը հետագայում նվազեցնում է այն մինչև ընդամենը 9.5 ԳԲ: Սա թույլ է տալիս գործարկել 15B պարամետր OctoCode մոդելը սպառողական GPU-ների վրա, ինչպիսին է RTX 3090-ը (24 ԳԲ VRAM):

Այնուամենայնիվ, նկատի ունեցեք, որ ավելի ագրեսիվ քվանտացումը, ինչպիսին 4-բիթն է, երբեմն կարող է հանգեցնել ճշգրտության նվազման՝ համեմատած 8 բիթ կամ bfloat16 ճշգրտության հետ: Հիշողության խնայողության և ճշգրտության միջև փոխզիջում կա, որը օգտվողները պետք է գնահատեն իրենց օգտագործման դեպքում:

Քվանտացումը հզոր տեխնիկա է, որը կարող է թույլ տալ LLM-ի տեղակայումը ռեսուրսներով սահմանափակ միջավայրերում, ինչպիսիք են ամպային օրինակները, ծայրամասային սարքերը կամ նույնիսկ բջջային հեռախոսները՝ կտրուկ նվազեցնելով հիշողության հետքը:

Հիշողության գնահատում ճշգրտման համար

Թեև քվանտացումը հիմնականում օգտագործվում է արդյունավետ եզրակացության համար, տեխնիկան, ինչպիսին է տենզորի զուգահեռությունը և մոդելի զուգահեռությունը, կարևոր են ուսուցման ընթացքում հիշողության պահանջները կառավարելու համար կամ նուրբ կարգավորում մեծ լեզվական մոդելներ.

Հիշողության առավելագույն սպառումը ճշգրտման ժամանակ սովորաբար 3-4 անգամ ավելի բարձր է, քան եզրակացությունը՝ հաշվի առնելով հիշողության լրացուցիչ պահանջները՝

• Գրադիենտներ
• Օպտիմիզատորի պետությունները
• Հետ տարածման համար պահվող առաջանցից ակտիվացումներ

Պահպանողական գնահատականն այն է, որ X միլիարդ պարամետրերով LLM-ի ճշգրտումը պահանջում է շուրջը 4 * (2X) = 8X ԳԲ VRAM-ի bfloat16 ճշգրտությամբ:

Օրինակ, 7B պարամետրի LLaMA մոդելի ճշգրտումը կպահանջի մոտավորապես 7 * 8 = 56 ԳԲ VRAM մեկ GPU bfloat16 ճշգրտությամբ: Սա գերազանցում է ընթացիկ GPU-ների հիշողության հզորությունը, ինչը պահանջում է բաշխված ճշգրտման տեխնիկա:

Բաշխված նուրբ թյունինգի տեխնիկա

Մեծ մոդելների համար GPU-ի հիշողության սահմանափակումները հաղթահարելու համար առաջարկվել են մի քանի բաշխված ճշգրտման մեթոդներ.

1. Տվյալների զուգահեռությունՏվյալների զուգահեռության դասական մոտեցումը կրկնում է ամբողջ մոդելը մի քանի GPU-ներում՝ միաժամանակ բաժանելով և բաշխելով ուսումնական տվյալների խմբաքանակները: Սա նվազեցնում է ուսուցման ժամանակը գծային կերպով GPU-ների քանակով, բայց չի նվազեցնում հիշողության առավելագույն պահանջը յուրաքանչյուր GPU-ի վրա:
2. ԶՐՈ Փուլ 3Տվյալների զուգահեռության առաջադեմ ձև, որը բաժանում է մոդելի պարամետրերը, գրադիենտները և օպտիմիզատորի վիճակները GPU-ներում: Այն նվազեցնում է հիշողությունը՝ համեմատած դասական տվյալների զուգահեռության հետ՝ ուսուցման տարբեր փուլերի ընթացքում յուրաքանչյուր GPU-ի վրա պահելով միայն պահանջվող բաժանված տվյալները:
3. Տենսորի զուգահեռությունՄոդելը կրկնօրինակելու փոխարեն, թենզորային զուգահեռությունը մոդելի պարամետրերը բաժանում է տողերի կամ սյունակների և բաշխում դրանք GPU-ների միջև: Յուրաքանչյուր GPU աշխատում է պարամետրերի, գրադիենտների և օպտիմիզատորի վիճակների բաժանված շարքի վրա, ինչը հանգեցնում է հիշողության զգալի խնայողության:
4. Խողովակաշարերի զուգահեռությունԱյս տեխնիկան բաժանում է մոդելի շերտերը տարբեր GPU-ների/աշխատողների վրա, որոնցից յուրաքանչյուրը կատարում է շերտերի ենթաբազմություն: Ակտիվացումները փոխանցվում են աշխատողների միջև, ինչը նվազեցնում է առավելագույն հիշողությունը, բայց ավելացնում է կապի ծախսերը:

Այս բաշխված մեթոդների համար հիշողության օգտագործման գնահատումը աննշան է, քանի որ պարամետրերի, գրադիենտների, ակտիվացումների և օպտիմիզատորի վիճակների բաշխումը տարբեր տեխնիկայով տարբերվում է: Ավելին, տարբեր բաղադրիչներ, ինչպիսիք են տրանսֆորմատորի մարմինը և լեզվի մոդելավորման գլուխը, կարող են դրսևորել հիշողության բաշխման տարբեր վարքագիծ:

LLMem լուծում

Հետազոտողները վերջերս առաջարկել են LLMem, լուծում, որը ճշգրիտ գնահատում է GPU-ի հիշողության սպառումը, երբ կիրառում է բաշխված ճշգրտման մեթոդներ LLM-ներում մի քանի GPU-ներում:

GPU-ի հիշողության օգտագործման գնահատում նախապես պատրաստված LLM-ի ճշգրտման համար

LLMem-ը հաշվի է առնում այնպիսի գործոններ, ինչպիսիք են պարամետրերի վերահամադրումը նախքան հաշվարկը (ZeRO Փուլ 3), արդյունքի հավաքումը հետընթաց անցումում (տենզորի զուգահեռություն) և տրանսֆորմատորի մարմնի և լեզվի մոդելավորման գլխի համար հիշողության բաշխման տարբեր ռազմավարություններ:

Փորձարարական արդյունքները ցույց են տալիս, որ LLMem-ը կարող է գնահատել GPU-ի հիշողության առավելագույն օգտագործումը մեկ GPU-ի վրա ճշգրտված LLM-ների համար՝ մինչև 1.6% սխալի գործակիցով, որը գերազանցում է ժամանակակից DNNMem-ի սխալի միջին մակարդակը: 42.6%. Մի քանի GPU-ների վրա ավելի քան միլիարդ պարամետր ունեցող LLM-ների վրա բաշխված ճշգրտման մեթոդներ կիրառելիս, LLMem-ը հասնում է տպավորիչ միջին սխալի մակարդակի՝ 3.0%.