🥇MLOps - Խոհարարական գիրք, գլուխ 1

Բարեւ բոլորին! Ես CV-ի մշակող եմ CROC-ում: Արդեն 3 տարի է, ինչ նախագծեր ենք իրականացնում CV-ի ոլորտում։ Այս ընթացքում մենք շատ բաներ արեցինք, օրինակ՝ վերահսկում էինք վարորդներին, որպեսզի վարելիս նրանք չխմեին, չծխեին, չխոսեին հեռախոսով, նայեին ճանապարհին, ոչ թե երազներին կամ ամպերին: ; Մենք արձանագրել ենք մարդկանց, ովքեր քշում են հատուկ գոտիներով և զբաղեցնում են մի քանի կայանատեղեր. ապահովել, որ աշխատողները կրեն սաղավարտներ, ձեռնոցներ և այլն. հայտնաբերել է աշխատակցին, ով ցանկանում է մուտք գործել հաստատություն. Մենք հաշվում էինք այն ամենը, ինչ կարող էինք:

Ինչի՞ համար եմ ես անում այս ամենը։

Նախագծերի իրականացման գործընթացում մենք հարվածներ ենք հասցրել, շատ բախումներ, որոշ խնդիրներ, որոնց կամ ծանոթ եք, կամ կծանոթանաք ապագայում:

Եկեք մոդելավորենք իրավիճակը

Պատկերացնենք, որ մենք աշխատանք գտանք երիտասարդ «N» ընկերությունում, որի գործունեությունը կապված է ՄԼ-ի հետ: Մենք աշխատում ենք ML (DL, CV) նախագծի վրա, հետո ինչ-ինչ պատճառներով անցնում ենք մեկ այլ աշխատանքի, հիմնականում ընդմիջում ենք և վերադառնում մեր կամ ուրիշի նեյրոնին:

Գալիս է ճշմարտության պահը, պետք է ինչ-որ կերպ հիշել, թե որտեղ եք կանգնել, ինչ հիպերպարամետրեր եք փորձել և, որ ամենակարեւորն է, ինչ արդյունքների են դրանք հանգեցրել։ Կարող են լինել բազմաթիվ տարբերակներ, թե ով է պահել տեղեկատվությունը բոլոր գործարկումների մասին՝ գլխում, կոնֆիգուրացիաներ, նոթատետրում, աշխատանքային միջավայրում՝ ամպի մեջ: Ես պատահաբար տեսա մի տարբերակ, երբ հիպերպարամետրերը պահվում էին որպես մեկնաբանված տողեր կոդի մեջ, ընդհանուր առմամբ, երևակայության թռիչք: Հիմա պատկերացրեք, որ դուք վերադարձել եք ոչ թե ձեր նախագծին, այլ ընկերությանը լքած մարդու նախագծին, և դուք ժառանգել եք կոդ և մոդել, որը կոչվում է model_1.pb: Պատկերն ամբողջացնելու և ամբողջ ցավը փոխանցելու համար եկեք պատկերացնենք, որ դուք նույնպես սկսնակ մասնագետ եք։
Շարունակիր. Կոդը գործարկելու համար մենք և բոլոր նրանք, ովքեր կաշխատեն դրա հետ, պետք է միջավայր ստեղծենք: Հաճախ է պատահում, որ ինչ-ինչ պատճառներով նրան չեն թողել որպես մեր ժառանգություն։ Սա նույնպես կարող է դառնալ ոչ տրիվիալ խնդիր։ Չե՞ք ուզում ժամանակ վատնել այս քայլի վրա, այնպես չէ՞:
Մենք պատրաստում ենք մոդել (օրինակ՝ մեքենայի դետեկտոր): Մենք հասնում ենք այն կետին, երբ այն դառնում է շատ լավ. ժամանակն է փրկել արդյունքը: Եկեք այն անվանենք car_detection_v1.pb: Հետո մարզում ենք ևս մեկը՝ car_detection_v2.pb: Որոշ ժամանակ անց մեր գործընկերները կամ մենք ինքներս ավելի ու ավելի շատ ենք սովորեցնում՝ օգտագործելով տարբեր ճարտարապետություններ։ Արդյունքում ձևավորվում են արտեֆակտների մի փունջ, որոնց մասին տեղեկատվությունը պետք է ջանասիրաբար հավաքել (բայց մենք դա կանենք ավելի ուշ, քանի որ առայժմ մենք ավելի առաջնահերթ խնդիրներ ունենք):
Լավ, հիմա ամեն ինչ ավարտված է: Մենք ունենք մոդել! Կարո՞ղ ենք սկսել հաջորդ մոդելի վերապատրաստումը, ճարտարապետություն մշակել՝ նոր խնդիր լուծելու համար, թե՞ կարող ենք գնալ թեյ խմելու: Իսկ ովքե՞ր են տեղակայելու:

Խնդիրների բացահայտում

Նախագծի կամ արտադրանքի վրա աշխատելը շատ մարդկանց աշխատանքն է: Եվ ժամանակի ընթացքում մարդիկ գնում-գալիս են, նախագծերը շատանում են, իսկ նախագծերն ինքնին բարդանում են։ Այսպես թե այնպես, իրավիճակները վերը նկարագրված ցիկլից (և ոչ միայն) որոշակի համակցություններում տեղի կունենան կրկնությունից կրկնություն: Այս ամենը հանգեցնում է անիմաստ ժամանակի, շփոթության, նյարդերի, հնարավոր է հաճախորդների դժգոհության և, ի վերջո, կորցրած գումարի: Թեև մենք բոլորս սովորաբար հետևում ենք նույն հին փոցխին, ես հավատում եմ, որ ոչ ոք չի ցանկանում նորից ու նորից վերապրել այս պահերը:

Այսպիսով, մենք անցել ենք զարգացման մեկ շրջան և տեսնում ենք, որ կան խնդիրներ, որոնք պետք է լուծվեն։ Դա անելու համար ձեզ հարկավոր է.

աշխատանքի արդյունքների հարմարավետ պահպանում;
հեշտացնել նոր աշխատակիցների ներգրավման գործընթացը.
պարզեցնել զարգացման միջավայրի տեղակայման գործընթացը.
կարգավորել մոդելի տարբերակման գործընթացը;
ունենալ մոդելները վավերացնելու հարմար միջոց.
գտնել պետության կառավարման մոդելային գործիք;
գտնել մոդելներ արտադրություն հասցնելու միջոց:

Ըստ երևույթին, անհրաժեշտ է մշակել աշխատանքային հոսք, որը թույլ կտա հեշտությամբ և հարմարավետ կառավարել այս կյանքի ցիկլը: Այս պրակտիկան կոչվում է MLOps

MLOps-ը կամ DevOps-ը մեքենայական ուսուցման համար թույլ է տալիս տվյալների գիտության և ՏՏ թիմերին համագործակցել և մեծացնել մոդելի մշակման և տեղակայման տեմպերը՝ մեքենայական ուսուցման մոդելների մոնիտորինգի, վավերացման և կառավարման միջոցով:

Դուք կարող եք կարդալԻ՞նչ են մտածում Google-ի տղաները այս ամենի մասին: Հոդվածից պարզ է դառնում, որ MLOps-ը բավականին ծավալուն բան է։

Հետագայում իմ հոդվածում ես նկարագրելու եմ գործընթացի միայն մի մասը: Իրականացման համար կօգտագործեմ MLflow գործիքը, քանի որ... Սա բաց կոդով նախագիծ է, միանալու համար պահանջվում է փոքր քանակությամբ կոդ, և կա ինտեգրում հայտնի ml շրջանակների հետ: Դուք կարող եք ինտերնետում որոնել այլ գործիքներ, ինչպիսիք են Kubeflow, SageMaker, Trains և այլն, և, հնարավոր է, գտնել մեկը, որն ավելի լավ է համապատասխանում ձեր կարիքներին:

MLO-ների «կառուցում»՝ օգտագործելով MLFlow գործիքի օգտագործման օրինակը

MLFlow-ը բաց կոդով հարթակ է ml մոդելների կյանքի ցիկլի կառավարման համար (https://mlflow.org/).

MLflow-ը ներառում է չորս բաղադրիչ.

MLflow Tracking - ընդգրկում է արդյունքների և պարամետրերի գրանցման խնդիրները, որոնք հանգեցրել են այս արդյունքին.
MLflow Project - թույլ է տալիս փաթեթավորել կոդը և վերարտադրել այն ցանկացած հարթակում;
MLflow մոդելներ - պատասխանատու են մոդելների արտադրության մեջ տեղակայելու համար.
MLflow Registry - թույլ է տալիս պահել մոդելները և կառավարել դրանց վիճակը կենտրոնացված պահոցում:

MLflow-ը գործում է երկու սուբյեկտի վրա.

մեկնարկը վերապատրաստման, պարամետրերի և չափումների ամբողջական ցիկլ է, որով մենք ցանկանում ենք գրանցվել.
Փորձը մի «թեմա» է, որն ընթանում է միասին:

Օրինակի բոլոր քայլերն իրականացվում են Ubuntu 18.04 օպերացիոն համակարգում:

1. Տեղադրեք սերվերը

Որպեսզի մենք հեշտությամբ կառավարենք մեր նախագիծը և ստանանք բոլոր անհրաժեշտ տեղեկությունները, մենք կտեղակայենք սերվեր: MLflow հետևող սերվերն ունի երկու հիմնական բաղադրիչ.

backend store - պատասխանատու է գրանցված մոդելների մասին տեղեկատվության պահպանման համար (աջակցում է 4 DBMS՝ mysql, mssql, sqlite և postgresql);
artifact store - պատասխանատու է արտեֆակտների պահպանման համար (աջակցում է պահպանման 7 տարբերակ՝ Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP սերվեր, SFTP Server, NFS, HDFS):

Ինչպես արտեֆակտերի խանութ Պարզության համար եկեք վերցնենք sftp սերվեր:

ստեղծել խումբ
```
$ sudo groupadd sftpg
```
ավելացնել օգտվող և նրա համար գաղտնաբառ սահմանել
```
$ sudo useradd -g sftpg mlflowsftp
$ sudo passwd mlflowsftp 
```

մի քանի մուտքի կարգավորումների կարգավորում

$ sudo mkdir -p /data/mlflowsftp/upload
$ sudo chown -R root.sftpg /data/mlflowsftp
$ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload

ավելացնել մի քանի տող /etc/ssh/sshd_config

Match Group sftpg
 ChrootDirectory /data/%u
 ForceCommand internal-sftp

վերագործարկեք ծառայությունը
```
$ sudo systemctl restart sshd
```

Ինչպես backend խանութ Վերցնենք postgresql.

$ sudo apt update
$ sudo apt-get install -y postgresql postgresql-contrib postgresql-server-dev-all
$ sudo apt install gcc
$ pip install psycopg2
$ sudo -u postgres -i
# Create new user: mlflow_user
[postgres@user_name~]$ createuser --interactive -P
Enter name of role to add: mlflow_user
Enter password for new role: mlflow
Enter it again: mlflow
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
# Create database mlflow_bd owned by mlflow_user
$ createdb -O mlflow_user mlflow_db

Սերվերը գործարկելու համար անհրաժեշտ է տեղադրել հետևյալ python փաթեթները (խորհուրդ եմ տալիս ստեղծել առանձին վիրտուալ միջավայր).

pip install mlflow
pip install pysftp

Եկեք գործարկենք մեր սերվերը

$ mlflow server  
                 --backend-store-uri postgresql://mlflow_user:mlflow@localhost/mlflow_db 
                 --default-artifact-root sftp://mlflowsftp:mlflow@sftp_host/upload  
                --host server_host 
                --port server_port

2. Ավելացնել հետագծում

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

Օրինակ, ես ստեղծել եմ փոքրիկ նախագիծ github-ում Keras-ի վրա՝ այն ամենն ինչ կա հատվածավորելու համար COCO տվյալների բազա. Հետևում ավելացնելու համար ես ստեղծեցի mlflow_training.py ֆայլ:

Ահա այն տողերը, որտեղ տեղի են ունենում ամենահետաքրքիր բաները.

def run(self, epochs, lr, experiment_name):
        # getting the id of the experiment, creating an experiment in its absence
        remote_experiment_id = self.remote_server.get_experiment_id(name=experiment_name)
        # creating a "run" and getting its id
        remote_run_id = self.remote_server.get_run_id(remote_experiment_id)

        # indicate that we want to save the results on a remote server
        mlflow.set_tracking_uri(self.tracking_uri)
        mlflow.set_experiment(experiment_name)

        with mlflow.start_run(run_id=remote_run_id, nested=False):
            mlflow.keras.autolog()
            self.train_pipeline.train(lr=lr, epochs=epochs)

        try:
            self.log_tags_and_params(remote_run_id)
        except mlflow.exceptions.RestException as e:
            print(e)

Այստեղ self.remote_server-ը փոքրիկ փաթաթում է mlflow.tracking մեթոդների վրա: MlflowClient (հարմարության համար եմ պատրաստել), որի օգնությամբ ստեղծում եմ փորձ ու գործարկում սերվերի վրա։ Հաջորդը, ես նշում եմ, թե որտեղ պետք է միավորվեն գործարկման արդյունքները (mlflow.set_tracking_uri(self.tracking_uri)): Ես միացնում եմ ավտոմատ գրանցումը mlflow.keras.autolog(): Ներկայումս MLflow Tracking-ն աջակցում է TensorFlow-ի, Keras-ի, Gluon XGBoost-ի, LightGBM-ի, Spark-ի ավտոմատ գրանցումը: Եթե դուք չեք գտել ձեր շրջանակը կամ գրադարանը, ապա միշտ կարող եք հստակ մուտք գործել: Մենք սկսում ենք մարզվել։ Գրանցեք պիտակներ և մուտքագրման պարամետրեր հեռավոր սերվերի վրա:

Մի քանի տող, և դուք, ինչպես բոլորը, հասանելի եք բոլոր գործարկումների մասին տեղեկատվությանը: Հիասքանչ?

3. Կազմում ենք նախագիծը

Հիմա եկեք հեշտացնենք նախագծի մեկնարկը: Դա անելու համար ծրագրի արմատին ավելացրեք MLproject և conda.yaml ֆայլը:
ML նախագիծ

name: flow_segmentation
conda_env: conda.yaml

entry_points:
  main:
    parameters:
        categories: {help: 'list of categories from coco dataset'}
        epochs: {type: int, help: 'number of epochs in training'}

        lr: {type: float, default: 0.001, help: 'learning rate'}
        batch_size: {type: int, default: 8}
        model_name: {type: str, default: 'Unet', help: 'Unet, PSPNet, Linknet, FPN'}
        backbone_name: {type: str, default: 'resnet18', help: 'exampe resnet18, resnet50, mobilenetv2 ...'}

        tracking_uri: {type: str, help: 'the server address'}
        experiment_name: {type: str, default: 'My_experiment', help: 'remote and local experiment name'}
    command: "python mlflow_training.py 
            --epochs={epochs}
            --categories={categories}
            --lr={lr}
            --tracking_uri={tracking_uri}
            --model_name={model_name}
            --backbone_name={backbone_name}
            --batch_size={batch_size}
            --experiment_name={experiment_name}"

MLflow Project-ն ունի մի քանի հատկություններ.

Անուն - ձեր նախագծի անվանումը;
Շրջակա միջավայր - իմ դեպքում conda_env-ը ցույց է տալիս, որ Anaconda-ն օգտագործվում է գործարկելու համար, և կախվածության նկարագրությունը գտնվում է conda.yaml ֆայլում;
Մուտքի կետեր - ցույց է տալիս, թե որ ֆայլերը և ինչ պարամետրերով կարող ենք գործարկել (բոլոր պարամետրերը ավտոմատ կերպով գրանցվում են մարզումը սկսելիս)

conda.yaml

name: flow_segmentation
channels:
  - defaults
  - anaconda
dependencies:
  - python==3.7
  - pip:
    - mlflow==1.8.0
    - pysftp==0.2.9
    - Cython==0.29.19
    - numpy==1.18.4
    - pycocotools==2.0.0
    - requests==2.23.0
    - matplotlib==3.2.1
    - segmentation-models==1.0.1
    - Keras==2.3.1
    - imgaug==0.4.0
    - tqdm==4.46.0
    - tensorflow-gpu==1.14.0

Դուք կարող եք օգտագործել docker-ը որպես ձեր գործարկման միջավայր, լրացուցիչ մանրամասների համար խնդրում ենք դիմել փաստաթղթավորում.

4. Սկսենք մարզվել

Մենք կլոնավորում ենք նախագիծը և գնում ծրագրի գրացուցակ.

git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/

Գործարկման համար անհրաժեշտ է տեղադրել գրադարաններ

pip install mlflow
pip install pysftp

Որովհետեւ Օրինակ, ես օգտագործում եմ conda_env, Anaconda-ն պետք է տեղադրված լինի ձեր համակարգչում (բայց դուք կարող եք դա շրջանցել՝ ինքներդ տեղադրելով բոլոր անհրաժեշտ փաթեթները և խաղալով գործարկման պարամետրերի հետ):

Բոլոր նախապատրաստական քայլերն ավարտված են, և մենք կարող ենք սկսել դասընթացը: Ծրագրի արմատից.

$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .

Հրաման մուտք գործելուց հետո ինքնաբերաբար կստեղծվի կոնդա միջավայր և կսկսվի ուսուցումը։
Վերևի օրինակում ես անցել եմ վերապատրաստման դարաշրջանների քանակը, այն կատեգորիաները, որոնց մենք ցանկանում ենք բաժանել (կարող եք տեսնել ամբողջական ցանկը այստեղ) և մեր հեռավոր սերվերի հասցեն:
Հնարավոր պարամետրերի ամբողջական ցանկը կարելի է գտնել MLproject ֆայլում:

5. Գնահատեք ուսուցման արդյունքները

Թրեյնինգն ավարտելուց հետո բրաուզերում կարող ենք գնալ մեր սերվերի հասցեով http://server_host:server_port

Այստեղ մենք տեսնում ենք բոլոր փորձերի ցանկը (վերևի ձախ կողմում), ինչպես նաև տեղեկություններ վազքի մասին (միջին): Մենք կարող ենք դիտել ավելի մանրամասն տեղեկատվություն (պարամետրեր, չափումներ, արտեֆակտներ և որոշ լրացուցիչ տեղեկություններ) յուրաքանչյուր գործարկման համար:

Յուրաքանչյուր չափման համար մենք կարող ենք դիտարկել փոփոխությունների պատմությունը

Նրանք. Այս պահին մենք կարող ենք վերլուծել արդյունքները «մեխանիկական» ռեժիմով, և դուք կարող եք նաև կարգավորել ավտոմատ վավերացումը՝ օգտագործելով MLflow API:

6. Գրանցեք մոդելը

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

Այն բանից հետո, երբ մենք անուն կտանք մեր մոդելին, այն ունի տարբերակ: Եթե պահպանեք նույն անունով մեկ այլ մոդել, տարբերակը ավտոմատ կերպով կթարմացվի:

Յուրաքանչյուր մոդելի համար մենք կարող ենք ավելացնել նկարագրությունը և ընտրել երեք վիճակներից մեկը (Staging, Production, Archived); այնուհետև, օգտագործելով API-ը, մենք կարող ենք մուտք գործել այս վիճակները, ինչը տարբերակման հետ մեկտեղ լրացուցիչ ճկունություն է ապահովում:

Մեզ հասանելի է նաև բոլոր մոդելները

և դրանց տարբերակները

Ինչպես նախորդ պարբերությունում, բոլոր գործողությունները կարող են կատարվել API-ի միջոցով:

7. Տեղադրեք մոդելը

Այս փուլում մենք արդեն ունենք պատրաստված (keras) մոդել։ Օրինակ, թե ինչպես կարող եք օգտագործել այն.

class SegmentationModel:
    def __init__(self, tracking_uri, model_name):

        self.registry = RemoteRegistry(tracking_uri=tracking_uri)
        self.model_name = model_name
        self.model = self.build_model(model_name)

    def get_latest_model(self, model_name):
        registered_models = self.registry.get_registered_model(model_name)
        last_model = self.registry.get_last_model(registered_models)
        local_path = self.registry.download_artifact(last_model.run_id, 'model', './')
        return local_path

    def build_model(self, model_name):
        local_path = self.get_latest_model(model_name)

        return mlflow.keras.load_model(local_path)

    def predict(self, image):
        image = self.preprocess(image)
        result = self.model.predict(image)
        return self.postprocess(result)

    def preprocess(self, image):
        image = cv2.resize(image, (256, 256))
        image = image / 255.
        image = np.expand_dims(image, 0)
        return image

    def postprocess(self, result):
        return result

Այստեղ self.registry-ը կրկին փոքրիկ փաթաթում է mlflow.tracking.MlflowClient-ի վրա՝ հարմարության համար: Բանն այն է, որ ես մուտք եմ գործում հեռավոր սերվեր և այնտեղ փնտրում եմ մոդել՝ նշված անունով և վերջին արտադրական տարբերակով։ Հաջորդը, ես ներբեռնում եմ արտեֆակտը տեղական ./model թղթապանակում և կառուցում մոդելը այս գրացուցակից mlflow.keras.load_model(local_path): Այժմ մենք կարող ենք օգտագործել մեր մոդելը: CV (ML) մշակողները կարող են հեշտությամբ բարելավել մոդելը և հրապարակել նոր տարբերակներ:

Վերջում

Ես ներկայացրել եմ մի համակարգ, որը թույլ է տալիս.

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

Այս օրինակը խաղալիք է և ծառայում է որպես ձեր սեփական համակարգի կառուցման մեկնարկային կետ, որը կարող է ներառել արդյունքների գնահատման ավտոմատացում և մոդելների գրանցում (համապատասխանաբար 5 և 6 կետեր), կամ կավելացնեք տվյալների հավաքածուների տարբերակները, կամ գուցե մեկ այլ բան: Այն կետը, որը ես փորձում էի նշել, այն է, որ ձեզ անհրաժեշտ են MLO-ներ որպես ամբողջություն, MLflow-ը պարզապես նպատակին հասնելու միջոց է:

Գրեք, թե ինչ խնդիրների եք հանդիպել, որոնք ես չեմ ցուցադրել։
Ի՞նչ կավելացնեիք համակարգին, որպեսզի այն բավարարի ձեր կարիքները:
Ի՞նչ գործիքներ և մոտեցումներ եք կիրառում բոլոր խնդիրները կամ դրանց մի մասը լուծելու համար:

Հ.Գ. Մի երկու հղում կթողնեմ.
github նախագիծ - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Հարցերի համար իմ աշխատանքային էլ. [էլեկտրոնային փոստով պաշտպանված]

Մեր ընկերությունը պարբերաբար կազմակերպում է տարբեր միջոցառումներ ՏՏ ոլորտի մասնագետների համար, օրինակ՝ հուլիսի 8-ին Մոսկվայի ժամանակով ժամը 19:00-ին տեղի կունենա CV-ի հանդիպում առցանց ձևաչափով, եթե հետաքրքրված եք, կարող եք մասնակցել, գրանցվել. այստեղ .

Source: www.habr.com

MLOps - Խոհարարական գիրք, գլուխ 1