Իմացեք, թե ինչպես է Docker-ը հեշտացնում մուտքը NVIDIA GPU-ներին, AWS Inferentia-ին և Kubernetes-ում ML կոնտեյներների մասշտաբացմանը:

Եթե ​​դուք ինձ մի քանի տարի առաջ ասեիք, որ տվյալների գիտնականները կօգտագործեն Docker կոնտեյներներ իրենց ամենօրյա աշխատանքում, ես ձեզ չէի հավատա: Որպես ավելի լայն մեքենայական ուսուցման (ML) համայնքի անդամ, ես միշտ դիտարկել եմ Docker, Kubernetes, Swarm (հիշո՞ւմ եք դա) էկզոտիկ ենթակառուցվածքային գործիքներ ՏՏ/Օփ փորձագետների համար: Այսօր դա այլ պատմություն է, հազվադեպ է անցնում մի օր, երբ ես չօգտագործեմ Docker կոնտեյներ՝ ուսուցման կամ մոդելի հյուրընկալման համար:

Մեքենայի ուսուցման մշակման հատկանիշը, որը տարբերվում է ավանդական ծրագրային ապահովման մշակումից, այն է, որ այն հենվում է մասնագիտացված ապարատների վրա, ինչպիսիք են GPU-ները, Habana Gaudi-ն, AWS Inferentia-ն՝ ուսուցումն ու եզրակացությունը արագացնելու համար: Սա դժվար է դարձնում կոնտեյներային տեղակայումները, որոնք ապարատային-ագնոստիկ են, ինչը բեռնարկղերի հիմնական առավելություններից մեկն է: Այս բլոգային գրառման մեջ ես կքննարկեմ, թե ինչպես են Docker-ի և կոնտեյներային տեխնոլոգիաները զարգացել այս մարտահրավերը լուծելու համար: Մենք կքննարկենք.

  • Ինչու՞ Docker-ը այսօր դարձել է մեքենայական ուսուցման կարևոր գործիք և ինչպես է այն լուծում մեքենայական ուսուցման հատուկ մարտահրավերներին
  • Ինչպես Docker-ը մուտք է գործում մասնագիտացված ապարատային ռեսուրսներ տարասեռ համակարգերի վրա, որոնք ունեն մեկից ավելի տեսակի պրոցեսորներ (CPU + AI արագացուցիչներ):
  • Ինչպես են տարբեր AI արագացուցիչներ երկարացնում Docker-ը ապարատային հասանելիության համար՝ 1/ NVIDIA GPU-ների և NVIDIA Container Toolkit-ի և 2/ AWS Inferentia-ի և Neuron SDK-ի աջակցության օրինակներով կոնտեյներների համար:
  • Ինչպես մեծացնել Docker բեռնարկղերը Kubernetes-ում ապարատային արագացված հանգույցներով

Այս բլոգի գրառման մեծ մասը մոտիվացիա է և «ինչպես է այն աշխատում գլխարկի տակ», բայց ես նաև ներառում եմ ցուցումներ, հղումներ և սքրինշոթներ այն մասին, թե ինչպես կարող եք սկսել Docker կոնտեյներները NVIDIA GPU-ներում կամ AWS Inferentia-ն AWS-ում, ուստի ինչ-որ բան կա: այստեղ և՛ սովորողի, և՛ պրակտիկանտի համար:

Docker-ը և մեքենայական ուսուցումը միասին չեն մեծացել (բայց նրանք այժմ լավագույն ընկերներ են)

Այսօր կազմակերպությունների մեծ մասը օգտագործում է Docker և կոնտեյներային տեխնոլոգիաները՝ մշակման և տեղակայման գործընթացը պարզեցնելու համար, քանի որ կոնտեյներային հավելվածները հետևողական են, շարժական և երաշխավորում են վերարտադրելիությունը: Թեև Docker կոնտեյներները պետք է լինեն և՛ ապարատային՝ագնոստիկ և՛ հարթակային՝ագնոստիկ, մեքենայական ուսուցման վրա հիմնված ծրագրաշարերի մեծ մասը ապարատային էհատուկ և մուտքի կարիք ունի։ հյուրընկալող ՕՀ-ի ապարատային և ապարատային դրայվերներին: Խնդիրն ավելի լավ հասկանալու համար եկեք ավելի սերտ նայենք մեքենայական ուսուցման տիպիկ ծրագրաշարի անատոմիային:

Տիպիկ մեքենայական ուսուցման ծրագրային փաթեթի անատոմիա

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

  • AI արագացուցչի ML գրադարաններ. Սրանք ցածր մակարդակի գրադարաններ են, որոնք օգտագործվում են ML շրջանակների կողմից՝ մեքենայական ուսուցման ուսուցման կամ AI արագացուցիչի սարքաշարի վրա եզրակացությունների առօրյան իրականացնելու համար: Նրանք իրականացնում են գծային հանրահաշիվ և այլ հաշվողական ինտենսիվ առօրյաներ, որոնք կարող են զուգահեռացվել և աշխատել AI արագացուցիչների վրա:
  • AI արագացուցիչ դրայվերներ. Սրանք դրայվերներ են, որոնք հյուրընկալող ՕՀ-ն օգտագործում է AI արագացուցիչ սարքաշարը ճանաչելու և աջակցելու համար:
  • AI արագացուցիչ. սա հատուկ պրոցեսոր է, որը նախատեսված է մեքենայական ուսուցման հաշվարկներն արագացնելու համար: Մեքենայական ուսուցումը հիմնականում բաղկացած է մատրիցա-մատրիցային մաթեմատիկական գործողություններից, և այս մասնագիտացված ապարատային պրոցեսորները նախատեսված են արագացնելու այդ հաշվարկները՝ օգտագործելով զուգահեռությունը: Արհեստական ​​ինտելեկտի արագացուցիչների մասին ավելին կարող եք կարդալ բլոգի այլ գրառումներում.

Այն համակարգերը, որոնք ունեն պրոցեսոր + այլ տեսակի պրոցեսորներ, կոչվում են տարասեռ համակարգեր։ Տարասեռ համակարգերը բարելավում են կատարողականությունը և արդյունավետությունը, քանի որ կան հատուկ պրոցեսորներ հատուկ առաջադրանքների համար, բայց դա պայմանավորված է բարդության բարձրացման գնով: Այս աճող բարդությունը մարտահրավեր է նետում ծրագրային փաթեթի շարժականության և մշակողների օգտատիրոջ փորձի հետ կապված: Սա այն մարտահրավերն է, որը պետք է անդրադառնա Դոկերը, և մենք ստորև կտեսնենք, թե ինչպես է դա անում:

Ինչպե՞ս է Docker-ն աջակցում հյուրընկալող սարքերին:

Լռելյայնորեն Docker կոնտեյներները մուտք չունեն հյուրընկալող OS-ի ռեսուրսներին, և դա նախագծված է: Docker կոնտեյներները նախատեսված են գործընթացի մեկուսացում առաջարկելու համար, հետևաբար օգտագործողը պետք է հստակ մուտք ապահովի հյուրընկալող ռեսուրսներին, ինչպիսիք են ծավալները և սարքերը: Դուք կարող եք դա անել՝ օգտագործելով —-devices փաստարկը, բայց դա գալիս է մի քանի նախազգուշացումներով:

Որոշ ապարատային սարքեր, ինչպիսիք են USB-ը և սերիական սարքերը, ունեն վարորդներ, որոնք աշխատում են միջուկի տարածքում, և Docker-ը պետք է ապավինի հյուրընկալող միջուկին և կատարի համակարգային զանգեր՝ սարքի սարքաշարի հետ փոխազդելու համար: Այս սարքերը հեշտությամբ հասանելի են Docker կոնտեյների գործընթացի ներսում՝ օգտագործելով the--device արգումենտը և տեղադրելով սարքը: Այնուամենայնիվ, այլ ապարատային սարքեր, ինչպիսիք են որոշ ցանցային քարտեր և AI արագացուցիչներ, ունեն վարորդներ, որոնք ունեն օգտվողի տարածքի բաղադրիչ և միջուկի տարածության մոդուլ: Այս դեպքում ձեզ հարկավոր է կրկնօրինակել վարորդի տեղադրումը հյուրընկալող ՕՀ-ում և Docker կոնտեյներով:

Ենթադրենք, որ ցանկանում եք գործարկել կոնտեյներային գործընթաց և ցանկանում եք բացահայտել սարքը, որը կոչվում է device_name0, ապա գործարկեք հետևյալ հրամանը.

docker run --device /dev/device_name0:/dev/device_name0 …

Եթե ​​device_name0-ն ունի և՛ օգտագործողի տարածք, և՛ միջուկի տարածության վարորդի բաղադրիչներ, ապա դուք պետք է նաև տեղադրեք սարքի դրայվերը Docker կոնտեյների ներսում, որը կրկնօրինակում է դրայվերը հյուրընկալողի և կոնտեյների միջավայրում, ինչպես ցույց է տրված այս բաժնի վերևի նկարում:

Այս կարգավորումն ունի մի քանի թերություններ.

  • Բեռնարկղերի չափի մեծացում.Ենթադրվում է, որ բեռնարկղերը թեթև և շարժական են, իսկ վարորդները հաճախ մեծ են և շատ տեղ են զբաղեցնում: Օրինակ, NVIDIA GPU-ի վերջին դրայվերները կարող են 350-ից 500 ՄԲ լրացուցիչ տարածք գրավել ձեր կոնտեյներով: Սա ավելացնում է կոնտեյների պատկերների ներբեռնման և ցուցումների ժամանակ, ինչը կարող է ազդել հապաղման զգայունության հավելվածների և օգտագործողի փորձի վրա
  • Վարորդի տարբերակի անհամապատասխանություն. Որպեսզի այս լուծումն աշխատի, բեռնարկղի միջավայրում և հյուրընկալող ՕՀ-ի վարորդի տարբերակները պետք է համապատասխանեն: Եթե ​​դրանք տարբեր են, ապա կոնտեյների գործընթացը չի կարող խոսել սարքավորման հետ:
  • Կարգավորման բարդություն.Վարորդների տեղադրումը տարաներում լրացուցիչ քայլեր են, և յուրաքանչյուր լրացուցիչ գրադարան կամ ծրագրակազմ, որը դուք տեղադրում եք կոնտեյների մեջ, ավելացնում է լրացուցիչ բարդություն և պետք է փորձարկվի:
  • Նվազեցված շարժունակությունը.Docker կոնտեյներները նախագծված էին թեթև, շարժական և ապարատային ագնոստիկ լինելու համար: Կոնտեյներների դրայվերները դարձնում են այն ծանր, ապարատային հատուկ, հատուկ հարթակին և հիմնականում վերացնում է Docker բեռնարկղերի բոլոր առավելությունները:

Նվազագույնը նպատակը պետք է լինի լուծել այս մարտահրավերները այնպիսի լուծումով, որը չի պահանջում սարքի դրայվերների կրկնօրինակում կոնտեյների ներսում, և Docker-ին թույլ է տալիս մուտք գործել համակարգի մի քանի կամ բոլոր AI արագացուցիչներ մի քանի արագացուցիչներով: Եկեք հիմա նայենք, թե ինչպես է Docker-ը լուծում այս մարտահրավերը:

Ինչպե՞ս ենք մենք ստիպում Docker-ին աշխատել մեքենայական ուսուցման մասնագիտացված սարքավորումների հետ:

Մենք կսկսենք բարձր մակարդակի արագ ամփոփումով, թե ինչպես է Docker-ը վարում կոնտեյներները: Երբ դուք օգտագործում եք Docker CLI-ը՝ docker run …-ի միջոցով բեռնարկղային գործընթաց սկսելու համար, տեղի է ունենում քայլերի հաջորդականություն, մինչև այն ի վերջո կանչի շատ կարևոր գրադարան՝ runC:

runC-ը Open Container Initiative-ի (OCI) համապատասխան գործիք է՝ ձվադրման և բեռնարկղային գործընթացների գործարկման համար, որն օգտագործվում է Docker, Podman, CRI-O և այլ հայտնի կոնտեյներների գործարկման ժամանակների կողմից: Երբ դուք օգտագործում եք Docker CLI-ը կոնտեյներ գործարկելու համար, Docker-ը runC-ին տրամադրում է OCI-ին համապատասխանող գործարկման ժամանակի հստակեցման ֆայլ (նկարում ցուցադրված է որպես «OCI spec») և կոնտեյների արմատային ֆայլային համակարգը, որը կոչվում է OCI համապատասխան Bundle, որը runC-ն ընդունում է որպես մուտքեր՝ ստեղծելու համար: և գործարկել կոնտեյների գործընթացը: OCI spec-ի ֆայլը դրույթներ ունի լրացուցիչ ընտրանքներ ներառելու համար, ինչպիսիք են նախնական և հետգործարկվող կեռիկները՝ այլ գործընթացներ սկսելու համար կոնտեյների մշակման ստեղծումից առաջ և հետո: Սարքավորումների մատակարարները կարող են օգտվել այս մանգաղից՝ կոնտեյների գործընթացին ապարատային հասանելիություն ներարկելու համար: Տեսնենք, թե ինչպես.

AI արագացուցիչ մատակարարները կարող են ընդլայնել runC-ի ֆունկցիոնալությունը՝ օգտագործելով նախնական մեկնարկային կեռիկները՝ արտաքին հավելվածով բեռնարկղի կյանքի ցիկլի մեջ կցելու համար: Այս արտաքին հավելվածը սովորաբար գրադարան է, որը խոսում է ապարատային վարորդի հետ և բացահայտում ապարատը կոնտեյների գործընթացում: Վերևի նկարի կապույտ արկղերը ցույց են տալիս, թե ինչպես կարող եք օգտագործել Docker և runC գործառույթները՝ գովազդելու մասնագիտացված սարքավորումները կոնտեյներային գործընթացում: Եկեք նայենք այս ընդհանուր ձևանմուշի բաղադրիչներին՝ Docker կոնտեյներներում մասնագիտացված ապարատային աջակցություն իրականացնելու համար.

  • հարմարեցված գործարկման ժամանակ. Docker-ը թույլ է տալիս սահմանել հատուկ գործարկման ժամանակ՝ օգտագործելով /etc/docker/daemon.json: Օգտագործելով սովորական գործարկման ժամանակը, դուք կարող եք ընդհատել Docker-ից ստացված OCI-ի հստակեցումը, ավելացնել նախնական մեկնարկային կեռիկ և թարմացված ճշգրտումը փոխանցել runC:
  • հարմարեցված կեռիկ. runC կարդում է նախնական մեկնարկի կեռիկը այն ճշգրտումից, որը ստացել է հատուկ գործարկման ժամանակից և կատարում է հատուկ կեռիկը: Այս հատուկ կեռիկը կանչում է ապարատային հատուկ գրադարան կամ գրադարաններ, որոնք կարող են խոսել ապարատային վարորդի հետ և բացահայտել այն կոնտեյների գործընթացում
  • custom-inject-hardware-library. Այս գրադարանը պատասխանատու է ապարատային վարորդի հետ հաղորդակցվելու համար՝ համակարգում ապարատային սարքավորումների և պրոցեսորների քանակի մասին տեղեկություններ հավաքելու համար: Այն նաև պատասխանատու է ապարատային սարքը կոնտեյների միջավայրում տեղադրելու և այն բեռնարկղային գործընթացում հավելվածների համար հասանելի դարձնելու համար:

Ստորև մենք կանդրադառնանք, թե ինչպես Docker-ը կարող է մուտք գործել NVIDIA GPU և AWS Inferentia:

NVIDIA GPU և AWS Inferentia Amazon EC2 օրինակների գործարկում

Սկզբում մենք կգործարկենք Amazon EC2 օրինակները՝ ցույց տալու համար, թե ինչպես է Docker-ն աշխատում մասնագիտացված սարքաշարի հետ: Հետևեք այս ուղեցույցին մեքենայական ուսուցման համար EC2 օրինակ գործարկելու համար: NVIDIA GPU-ների համար ընտրեք P կամ G ընտանիքի օրինակների տեսակների ցանկացած չափ: Եթե ​​օգնության կարիք ունեք AWS-ում խորը ուսուցման համար ճիշտ GPU ընտրելու համար, կարդացեք իմ բլոգի գրառումը.



Ընտրելով ճիշտ GPU խորը ուսուցման համար AWS-ում
Ինչպես ընտրել Amazon EC2 GPU-ի ճիշտ օրինակը խորը ուսուցման ուսուցման և եզրակացության համար՝ լավագույն կատարումից մինչև… todatascience.com



AWS Inferentia օրինակների համար ընտրեք Inf1 օրինակի տեսակը: Այս օրինակում ես գործարկում եմ inf1.2xlarge (AWS Inferentia) և p3.8xlarge (4 x NVIDIA V100 GPU):

Երբ դուք ընտրեք ձեր օրինակի տեսակը, դուք պետք է ընտրեք Amazon Machine Image (AMI), և մենք կօգտագործենք AWS Deep Learning AMI, որը գալիս է GPU-ի դրայվերներով, AWS Inferentia դրայվերներով, խորը ուսուցման շրջանակներով, conda-ով և այլն: նախապես տեղադրված գործիքներ. Ընտրեք AMI՝ ձեր աշխատանքի համար անհրաժեշտ խորը ուսուցման շրջանակի ճիշտ տեսակով և տարբերակով, այս օրինակի համար ես կընտրեմ Multi-framework DLAMI-ը Ubuntu 18.04-ի համար:

Ձեր Amazon EC2 օրինակները գործարկելուց հետո դուք կարող եք դրանք տեսնել ձեր EC2 վահանակի վրա և կարող եք ssh-ի մեջ մտնել ձեր հավելվածները գործարկելու համար: Կարող եք նաև կարդալ իմ բլոգի գրառումը Ինչու՞ օգտագործել Docker կոնտեյներները մեքենայական ուսուցման զարգացման համար: EC2-ով աշխատող Docker կոնտեյների մեջ ssh-ի և կարգավորելու jupyter սերվերի շրջագծման համար:

Մուտք գործեք NVIDIA GPU-ներ Docker կոնտեյներներում

NVIDIA-ն առաջարկում է NVIDIA Container Toolkit-ը՝ գործիքների և գրադարանների հավաքածու, որն ավելացնում է Docker կոնտեյներներում GPU-ների աջակցությունը:

docker run --runtime=nvidia --gpus=all …

Երբ գործարկում եք վերը նշված հրամանը, NVIDIA Container Toolkit-ը երաշխավորում է, որ համակարգի GPU-ները հասանելի են կոնտեյների գործընթացում: Քանի որ մենք գործարկեցինք Amazon EC2 օրինակը AWS Deep Learning AMI-ով, ձեզ հարկավոր չէ տեղադրել NVIDIA Container Toolkit-ը, քանի որ այն նախապես տեղադրված է: Եթե ​​դուք սկսում եք բազային AMI-ից, հետևեք NVIDIA Container Toolkit փաստաթղթերի տեղադրման հրահանգին:

Ինչպես է աշխատում NVIDIA Container Toolkit-ը

NVIDIA Container Toolkit-ը ներառում է nvidia-container-runtime, nvidia-container-runtime-hook և libnvidia-container: Եկեք նայենք, թե ինչպես են դրանք աշխատում:

NVIDIA Container Toolkit-ը գրանցում է հատուկ գործարկման ժամանակ՝ նշելով այն /etc/docker/daemon.json-ում: Այս մաքսային գործարկման ժամանակը մի շեմ է, որը վերցնում է գործարկման ժամանակի հստակեցումը Docker-ից, այն փոփոխում է մինչև մեկնարկային կեռիկի ճշգրտումը և սպեցիֆիկցիան փոխանցում է runC:

NVIDIA Container Toolkit-ը նաև թույլ է տալիս կարգավորել կոնտեյների գործարկման ժամանակը՝ օգտագործելով ֆայլի վրա հիմնված կոնֆիգուրացիա: Դուք կարող եք խմբագրել /etc/nvidia-container-runtime/config.toml ֆայլը՝ ձեր վարորդների համար տարբեր վայրեր նշելու համար, գործարկման ժամանակը, փոխելու լռելյայն գործարկման ժամանակը, միացնել վրիպազերծումը և այլն: Դուք կարող եք թողնել կանխադրվածները, եթե չունեք հատուկ կարգավորում:

Ենթադրենք, դուք գործարկել եք հետևյալ հրամանը

docker run --runtime=nvidia --gpus=2 …

Docker-ը վերցնում է հրամանի տողի արգումենտները և այն թարգմանում OCI-ին համապատասխանող գործարկման ժամանակի սպեկտրով: nvidia-container-runtime-ն ավելացնում է նախնական մեկնարկը այս բնութագրին և այն փոխանցում է runCին: Այնուհետև, runC-ը տեսնում է նախնական մեկնարկի կեռիկը փոփոխված սպեկտրում և կանչում է nvidia-container-runtime-hook-ը նախքան բեռնարկղերի գործընթացը սկսելը: nvidia-container-runtime-hook-ը նայում է կոնտեյների գործարկման ժամանակի կազմաձևին, որպեսզի որոշի, թե որ GPU կամ քանի GPU եք խնդրել բացահայտել կոնտեյների գործընթացում: Այնուհետև այն կանչում է libnvidia-container գրադարանը, որը զրուցում է NVIDIA վարորդի հետ՝ որոշելու, թե արդյոք պահանջվող GPU-ների քանակը (այս օրինակում մենք ասացինք--gpus=2) հասանելի են, և եթե դրանք կան, այն ներարկում է այդ GPU սարքերը կոնտեյների մեջ:

GPU-ի հասանելիությունը ստուգելու համար ես պատրաստվում եմ դուրս բերել Pytorch կոնտեյները Amazon-ի խորը ուսուցման բեռնարկղերի ցանկից, որոնք հյուրընկալում են Amazon ECR-ում: Հետևեք այդ էջի հրահանգներին՝ մուտք գործելու Amazon ECR և գործարկելու docker pull <IMAGE_NAME>: Այնուհետև գործարկեք հետևյալ հրամանը՝ կոնտեյները գործարկելու համար:

docker run -it --rm --runtime=nvidia — gpus=all <IMAGE_NAME/ID> nvidia-smi

Արդյունքից մենք կարող ենք տեսնել, որ ես կարող եմ գործարկել nvidia-smi գործիքը, որը հարցումներ է պահանջում և ցուցադրում բոլոր 4 GPU-ները, որոնք հասանելի են այս EC2 օրինակում և կարող են մուտք գործել կոնտեյների ներսից:

Նշում.--runtime=nvidia պարտադիր չէ, եթե օգտագործում եք Docker-ի և NVIDIA Container Toolkit-ի վերջին տարբերակները

Եթե ​​ցանկանում եք բացել միայն 2 GPU-ն կոնտեյների ներսում, ապա կարող եք պարզապես նշել –-gpus=2 կամ թվարկել, թե որ երկուսը ցանկանում եք հասանելի լինել կոնտեյների ներսում.

docker run -it — rm — runtime=nvidia — gpus=2 <IMAGE_NAME/ID> nvidia-smi
# OR
docker run -it — rm — runtime=nvidia — gpus=’”device=0,1"’ <IMAGE_NAME/ID> nvidia-smi

Մուտք գործեք AWS Inferentia արագացուցիչներ Docker բեռնարկղերում

Ձեր Inf1 Amazon EC2 օրինակը AWS Inferentia-ով պատրաստելու համար կարող եք հետևել AWS Neuron փաստաթղթերի քայլերին՝ տեղադրելու Neuron դրայվերները, Neuron-ի գործարկման ժամանակը և oci-add-hooks կոչվող օգնական գրադարանը, որը հեշտացնում է OCI նեյրոնի նախնական մեկնարկի կեռիկներ ավելացնելը:

Ինչպես է աշխատում Docker-ի աջակցությունը AWS Inferentia-ին

Neuron SDK-ն տեղադրելուց և Docker միջավայրի տեղադրման քայլերին հետևելուց հետո ձեր համակարգը պետք է ունենա oci-neuron-runtime, oci-neuron-hook: Եկեք նայենք, թե ինչպես են նրանք աշխատում:

NVIDIA Container Toolkit-ի նման, Neuron SDK-ն գրանցում է հատուկ գործարկման ժամանակ՝ նշելով այն /etc/docker/daemon.json-ում: Ստորև ներկայացված սքրինշոթից կարող եք տեսնել, որ սովորական Docker-ի գործարկման ժամանակը պարզապես կեղևի սցենար է: Հիշեք, որ սովորական գործարկման ժամանակի դերն այն է, որ պարզապես ընդհատել զանգը runC-ին, փոփոխել այն՝ ներառելով նախապես մեկնարկային կեռիկի հստակեցում և զանգահարել runC թարմացված սպեկտրով:

Եկեք բացենք oci_neuron_hook_wrapper.sh տեսնենք, թե ինչ է անում.

  • Նշում է ուղին դեպի oci_neuron_hook_config.json, JSON ֆայլ, որը սահմանում է, թե ինչ գրադարան պետք է կանչի նախնական մեկնարկը
  • Ստանում է runC գրադարանի գտնվելու վայրը
  • Օգտագործում է oci-add-hooks գործիքը, որը կարող է վերցնել նախնական կեռիկի սահմանումը oci_neuron_hook_config.json կոչվող ֆայլից և ստեղծել թարմացված գործարկման սպեկտր և փոխանցել այն runCին:

Մենք կարող ենք բացել oci_neuron_hook_config.json-ը, և դուք կարող եք տեսնել oci_neuron_hook-ը, որն այն գրադարանն է, որը կանչվել է runC-ի կողմից՝ նախքան կոնտեյների գործընթացը ստեղծելը:

oci_neuron_hook գրադարանը զրուցում է AWS Inferentia վարորդի հետ՝ որոշելու, թե արդյոք AWS Inferentia սարքերի պահանջվող թիվը հասանելի է, և արդյոք դրանք կան, այն ներարկում է այդ սարքերը կոնտեյների մեջ: AWS Inferentia-ի աջակցությունը Docker-ում փորձարկելու համար ներբեռնեք հետևյալ Docker ֆայլը և գործարկեք.

docker build . -f Dockerfile.app -t neuron-test
docker images

Եվ դուք պետք է տեսնեք նեյրոնային թեստի պատկեր

Գործարկել կոնտեյները

docker run — env — runtime=oci-neuron AWS_NEURON_VISIBLE_DEVICES=”0" neuron-test neuron-ls

Եվ դուք կարող եք տեսնել, որ Neuron Device 0-ը ցուցադրվում է նեյրոն-ls-ի ելքով, որն իրականացվել է կոնտեյների գործընթացի ներսում: Նշում. –-runtime=oci-neuron-ը պարտադիր չէ, քանի որ նեյրոնը լռելյայն գործարկման ժամանակն է, ինչպես կարող եք տեսնել ստորև:

Kubernetes-ի աջակցություն NVIDIA GPU-ների և AWS Inferentia-ի համար

Մինչ այժմ մենք տեսել ենք, թե ինչպես Docker-ը կարող է մուտք ապահովել մասնագիտացված սարքաշար, ինչպիսիք են NVIDIA GPU-ները և AWS Inferentia-ն կոնտեյների ներսում, սա թույլ է տալիս ավելի շարժական մեքենայական ուսուցման կոդ: Բնական հաջորդ քայլը պարզելն է, թե ինչպես կարելի է գործարկել այս Docker կոնտեյներները Kubernetes-ի նման նվագախմբային համակարգում, որպեսզի կարողանաք գործարկել լայնածավալ տեղակայումներ: Այս թեման արժանի է իր սեփական մանրամասն բլոգային գրառմանը, բայց ես նպատակ կունենամ արագ ամփոփել, թե ինչպես կարող եք մուտք գործել AI արագացուցիչ ռեսուրսներ Kubernetes-ում՝ հանուն ամբողջականության:

Ինչպես NVIDIA-ի, այնպես էլ AWS Inferentia-ի համար, Kubernetes-ի յուրաքանչյուր հանգույցի հյուրընկալող ՕՀ-ն պետք է ներառի համապատասխան ապարատային դրայվերները, հատուկ կոնտեյների գործարկման ժամանակները և այլ գրադարաններ, որոնք մենք ավելի վաղ քննարկել ենք, որոնք թույլ են տալիս մասնագիտացված ապարատային աջակցություն Docker կոնտեյներներում: Amazon EKS կլաստեր գործարկելու ամենադյուրին ճանապարհը eksctl CLI գործիքն օգտագործելն է։

  • NVIDIA GPU-ների հանգույցների համար նշեք Amazon Deep Learning AMI-ը որպես AMI ձեր հանգույցների համար eksctl-ում, քանի որ այն գալիս է նախապես տեղադրված NVIDIA Container Toolkit-ով:
  • AWS Inferentia հանգույցների համար eksctl գործիքը ավտոմատ կերպով կհայտնաբերի, որ դուք ունեք AWS Inferentia հանգույց և կօգտագործի Amazon Linux AMI-ները՝ նախապես տեղադրված Neuron SDK-ով, դրայվերներով և Docker-ի աջակցման գրադարաններով:

Հաջորդը, այս AI արագացուցիչները որպես համակարգային ռեսուրս Kubernetes-ում հասանելի դարձնելու համար դուք պետք է տեղակայեք Kubernetes սարքի հավելումը հատուկ սարքաշարին: Ե՛վ NVIDIA-ն, և՛ AWS-ն ապահովում են սարքի պլագիններ, որոնք կարող եք կիրառել հետևյալ կերպ.

AWS եզրակացություն.

kubectl apply -f k8s-neuron-device-plugin.yml

Սարքի այս փլագինը, որը կարող եք ներբեռնել Neuron SDK-ի փաստաթղթերից, աշխատում է որպես daemonset և գովազդում է սարքաշարը պատիճների պարունակության մեջ, և դուք կարող եք նշել AWS Inferentia սարքաշարը ռեսուրսների տակ մանիֆեստում հետևյալ կերպ.

resources:
    limits:
        aws.amazon.com/neuron: 1

NVIDIA GPU-ներ.

kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v1.12/nvidia-device-plugin.yml

NVIDIA սարքի այս պլագինն աշխատում է նաև որպես daemonset և գովազդում է սարքավորումները pods-ում, և դուք կարող եք նշել NVIDIA GPU սարքաշարը ռեսուրսների տակ մանիֆեստում հետևյալ կերպ.

resources:
    limits:
        nvidia.com/gpu: 1

Դուք կարող եք գտնել ավելի մանրամասն հրահանգներ, թե ինչպես սկսել AWS Inferentia-ի և NVIDIA GPU-ի համար Amazon EKS փաստաթղթերի էջերում:

Փակվում է (և այո, կա տեսանյութ):

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

Շնորհակալություն մինչև վերջ կարդալու համար:

Եթե ​​ձեզ համար այս հոդվածը հետաքրքիր է, մտածեք, որ հետևեք ինձ մեդիումով, որպեսզի նոր հոդվածներ հրապարակելիս տեղեկացված լինեք: Խնդրում եմ նաև ստուգել իմ մյուս բլոգային գրառումները medium-ում կամ հետևել ինձ Twitter-ում (@shshnkp), LinkedIn-ում կամ թողնել մեկնաբանություն ստորև: Ուզու՞մ եք գրել մեքենայական ուսուցման կոնկրետ թեմայի շուրջ: Ես կցանկանայի լսել ձեզնից: