🥇MLOps - Kuchárska kniha, kapitola 1

Ahojte všetci! Som vývojár životopisov v CROC. Projekty v oblasti CV realizujeme už 3 rok. Počas tejto doby sme robili veľa vecí, napríklad: monitorovali sme vodičov, aby počas jazdy nepili, nefajčili, netelefonovali, nepozerali sa na cestu a nie na sny či oblaky. ; Zaznamenali sme, že fanúšikovia jazdia vo vyhradených pruhoch a zaberajú niekoľko parkovacích miest; zabezpečiť, aby pracovníci nosili prilby, rukavice atď.; identifikoval zamestnanca, ktorý chce vstúpiť do zariadenia; Spočítali sme všetko, čo sa dalo.

Načo to všetko robím?

V procese implementácie projektov sme narazili na veľké problémy, na niektoré problémy, ktoré buď poznáte, alebo sa s nimi v budúcnosti zoznámite.

Simulujme situáciu

Predstavme si, že sme sa zamestnali v mladej spoločnosti „N“, ktorej aktivity súvisia s ML. Pracujeme na projekte ML (DL, CV), potom z nejakého dôvodu prejdeme na inú prácu, zvyčajne si dáme prestávku a vrátime sa do vlastného alebo cudzieho neurónu.

Prichádza chvíľa pravdy, treba si nejako spomenúť, kde ste sa zastavili, aké hyperparametre ste skúšali a hlavne, k akým výsledkom viedli. Môže existovať veľa možností, kto uložil informácie o všetkých spustení: v hlave, konfiguráciách, poznámkovom bloku, v pracovnom prostredí v cloude. Náhodou som videl možnosť, keď boli hyperparametre uložené ako komentované riadky v kóde, vo všeobecnosti je to fantázia. Teraz si predstavte, že ste sa nevrátili k svojmu projektu, ale k projektu človeka, ktorý z firmy odišiel a vy ste zdedili kód a model s názvom model_1.pb. Na dokončenie obrazu a vyjadrenie všetkej bolesti si predstavme, že ste tiež začiatočník špecialista.
Pokračuj. Na spustenie kódu musíme my a všetci, ktorí s ním budú pracovať, vytvoriť prostredie. Často sa stáva, že ho z nejakého dôvodu nezanechali ako naše dedičstvo. Môže sa to stať aj netriviálnou úlohou. Nechcete strácať čas týmto krokom, však?
Trénujeme model (napríklad detektor áut). Dostávame sa do bodu, kedy to bude veľmi dobré – je čas uložiť výsledok. Nazvime to car_detection_v1.pb. Potom trénujeme ďalší - car_detection_v2.pb. O nejaký čas neskôr naši kolegovia alebo my sami vyučujeme viac a viac pomocou rôznych architektúr. Výsledkom je, že sa vytvorí veľa artefaktov, o ktorých je potrebné starostlivo zbierať informácie (ale to urobíme neskôr, pretože teraz máme prioritnejšie záležitosti).
Dobre, teraz je po všetkom! Máme modelku! Môžeme začať trénovať ďalší model, vyvíjať architektúru na vyriešenie nového problému, alebo môžeme ísť na čaj? A kto nasadí?

Identifikácia problémov

Práca na projekte alebo produkte je prácou mnohých ľudí. A časom ľudia odchádzajú a prichádzajú, projektov je viac a samotné projekty sa stávajú zložitejšími. Tak či onak, situácie z cyklu opísaného vyššie (nielen) v určitých kombináciách nastanú od iterácie po iteráciu. To všetko má za následok premárnený čas, zmätok, nervy, možno aj nespokojnosť zákazníkov a v konečnom dôsledku aj stratené peniaze. Aj keď sa väčšinou všetci riadime tými istými starými hrablemi, verím, že nikto nechce tieto chvíle znova a znova prežívať.

Takže sme prešli jedným vývojovým cyklom a vidíme, že existujú problémy, ktoré treba vyriešiť. K tomu potrebujete:

pohodlne ukladať výsledky práce;
zjednodušiť proces zapojenia nových zamestnancov;
zjednodušiť proces nasadenia vývojového prostredia;
nakonfigurovať proces tvorby verzií modelu;
mať pohodlný spôsob overovania modelov;
nájsť modelový nástroj riadenia štátu;
nájsť spôsob, ako dodať modely do výroby.

Zrejme je potrebné vymyslieť pracovný postup, ktorý by vám umožnil jednoducho a pohodlne riadiť tento životný cyklus? Táto prax sa nazýva MLOps

MLOps alebo DevOps pre strojové učenie umožňuje dátovým vedeckým a IT tímom spolupracovať a zvýšiť tempo vývoja a nasadenia modelov prostredníctvom monitorovania, overovania a riadenia modelov strojového učenia.

Môžete to urobiť česťČo si o tom všetkom myslia ľudia z Googlu? Z článku je jasné, že MLOps je dosť objemná vec.

Ďalej v mojom článku popíšem len časť procesu. Na implementáciu použijem nástroj MLflow, pretože... Toto je projekt s otvoreným zdrojovým kódom, na pripojenie je potrebné malé množstvo kódu a existuje integrácia s populárnymi rámcami ml. Na internete môžete vyhľadať ďalšie nástroje, ako sú Kubeflow, SageMaker, Trains atď., a možno nájsť nástroj, ktorý lepšie vyhovuje vašim potrebám.

„Building“ MLOps pomocou príkladu použitia nástroja MLFlow

MLFlow je open source platforma pre správu životného cyklu modelov ml (https://mlflow.org/).

MLflow obsahuje štyri komponenty:

MLflow Tracking – pokrýva problematiku zaznamenávania výsledkov a parametrov, ktoré viedli k tomuto výsledku;
Projekt MLflow - umožňuje vám zbaliť kód a reprodukovať ho na akejkoľvek platforme;
Modely MLflow – zodpovedné za nasadenie modelov do výroby;
MLflow Registry - umožňuje ukladať modely a spravovať ich stav v centralizovanom úložisku.

MLflow funguje na dvoch entitách:

spustenie je celý cyklus školení, parametrov a metrík, podľa ktorých sa chceme zaregistrovať;
Experiment je „téma“, ktorá sa spája.

Všetky kroky príkladu sú implementované na operačnom systéme Ubuntu 18.04.

1. Nasaďte server

Aby sme mohli jednoducho riadiť náš projekt a dostávať všetky potrebné informácie, nasadíme server. Server sledovania MLflow má dve hlavné súčasti:

backend store - zodpovedný za ukladanie informácií o registrovaných modeloch (podporuje 4 DBMS: mysql, mssql, sqlite a postgresql);
Artifact store - zodpovedný za ukladanie artefaktov (podporuje 7 možností ukladania: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP server, SFTP Server, NFS, HDFS).

Vzhľadom k tomu, obchod s artefaktmi Pre jednoduchosť si zoberme sftp server.

vytvoriť skupinu
```
$ sudo groupadd sftpg
```

pridajte používateľa a nastavte mu heslo

$ sudo useradd -g sftpg mlflowsftp
$ sudo passwd mlflowsftp

úprava niekoľkých nastavení prístupu

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

pridajte niekoľko riadkov do /etc/ssh/sshd_config

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

reštartujte službu
```
$ sudo systemctl restart sshd
```

Vzhľadom k tomu, backendový obchod Vezmime si 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

Ak chcete spustiť server, musíte nainštalovať nasledujúce balíčky python (odporúčam vytvoriť samostatné virtuálne prostredie):

pip install mlflow
pip install pysftp

Spustíme náš server

$ 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. Pridajte sledovanie

Aby sa výsledky nášho školenia nestratili, budúce generácie vývojárov pochopili, čo sa dialo, a aby ste starší súdruhovia a vy mohli pokojne analyzovať proces učenia, musíme pridať sledovanie. Sledovanie znamená ukladanie parametrov, metrík, artefaktov a akýchkoľvek dodatočných informácií o začiatku tréningu, v našom prípade, na server.

Napríklad som vytvoril malý projekt na github na Kerase za segmentáciu všetkého, čo je in Súbor údajov COCO. Na pridanie sledovania som vytvoril súbor mlflow_training.py.

Tu sú riadky, kde sa dejú najzaujímavejšie veci:

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 je tu malý obal na metódy mlflow.tracking. MlflowClient (vyrobil som ho pre pohodlie), pomocou ktorého vytvorím experiment a spustím ho na serveri. Ďalej uvádzam, kde by sa mali zlúčiť výsledky spustenia (mlflow.set_tracking_uri(self.tracking_uri)). Povolím automatické protokolovanie mlflow.keras.autolog(). V súčasnosti MLflow Tracking podporuje automatické protokolovanie pre TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Ak ste nenašli svoj rámec alebo knižnicu, vždy sa môžete explicitne prihlásiť. Začíname trénovať. Zaregistrujte značky a vstupné parametre na vzdialenom serveri.

Pár riadkov a vy, rovnako ako všetci ostatní, máte prístup k informáciám o všetkých spustení. v pohode?

3. Vypracujeme projekt

Teraz si uľahčime spustenie projektu. Ak to chcete urobiť, pridajte MLproject a súbor conda.yaml do koreňového adresára projektu.
MLprojekt

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}"

Projekt MLflow má niekoľko vlastností:

Name – názov vášho projektu;
Prostredie – v mojom prípade conda_env označuje, že na spustenie sa používa Anaconda a popis závislosti je v súbore conda.yaml;
Vstupné body - označuje, ktoré súbory a s akými parametrami môžeme spustiť (všetky parametre sa automaticky zaznamenávajú pri začatí tréningu)

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 môžete použiť ako svoje runtime prostredie, ďalšie podrobnosti nájdete na dokumentáciu.

4. Začnime trénovať

Naklonujeme projekt a prejdeme do adresára projektu:

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

Ak chcete spustiť, musíte nainštalovať knižnice

pip install mlflow
pip install pysftp

Pretože v príklade, ktorý používam conda_env, musí byť Anaconda nainštalovaná na vašom počítači (ale môžete to obísť tak, že si sami nainštalujete všetky potrebné balíčky a pohráte sa s parametrami spustenia).

Všetky prípravné kroky sú ukončené a môžeme začať s tréningom. Z koreňa projektu:

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

Po zadaní príkazu sa automaticky vytvorí prostredie conda a spustí sa tréning.
Vo vyššie uvedenom príklade som prešiel počet epoch na školenie, kategórie, do ktorých chceme segmentovať (úplný zoznam si môžete pozrieť tu) a adresu nášho vzdialeného servera.
Kompletný zoznam možných parametrov nájdete v súbore MLproject.

5. Hodnotiť výsledky učenia

Po ukončení školenia môžeme prejsť v prehliadači na adresu nášho servera http://server_host:server_port

Tu vidíme zoznam všetkých experimentov (vľavo hore), ako aj informácie o behoch (uprostred). Pri každom spustení si môžeme zobraziť podrobnejšie informácie (parametre, metriky, artefakty a niektoré ďalšie informácie).

Pre každú metriku môžeme sledovať históriu zmien

Tie. V súčasnosti vieme výsledky analyzovať v „manuálnom“ režime a taktiež si môžete nastaviť automatickú validáciu pomocou MLflow API.

6. Zaregistrujte model

Potom, čo sme analyzovali náš model a rozhodli sme sa, že je pripravený na boj, pokračujeme v jeho registrácii, na to vyberieme spustenie, ktoré potrebujeme (ako je uvedené v predchádzajúcom odseku) a ideme dole.

Potom, čo dáme nášmu modelu meno, má verziu. Ak uložíte iný model s rovnakým názvom, verzia sa automaticky aktualizuje.

Ku každému modelu môžeme pridať popis a vybrať jeden z troch stavov (Staging, Production, Archived), následne pomocou API môžeme k týmto stavom pristupovať, čo spolu s verzovaním poskytuje ďalšiu flexibilitu.

Máme tiež jednoduchý prístup ku všetkým modelom

a ich verzie

Rovnako ako v predchádzajúcom odseku, všetky operácie je možné vykonávať pomocou API.

7. Nasaďte model

V tejto fáze už máme natrénovaný (keras) model. Príklad, ako ho môžete použiť:

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

Tu self.registry je opäť malý obal nad mlflow.tracking.MlflowClient, pre pohodlie. Ide o to, že pristupujem na vzdialený server a hľadám tam model so zadaným názvom a najnovšou produkčnou verziou. Ďalej stiahnem artefakt lokálne do priečinka ./model a zostavím model z tohto adresára mlflow.keras.load_model(local_path). Teraz môžeme použiť náš model. Vývojári CV (ML) môžu jednoducho vylepšiť model a publikovať nové verzie.

na záver

Predstavil som systém, ktorý umožňuje:

centrálne ukladať informácie o modeloch ML, priebehu a výsledkoch školenia;
rýchle nasadenie vývojového prostredia;
monitorovať a analyzovať postup prác na modeloch;
je vhodné verzovať a spravovať stav modelov;
Nasadenie výsledných modelov je jednoduché.

Tento príklad je hračka a slúži ako štartovací bod pre budovanie vlastného systému, ktorý môže zahŕňať automatizáciu vyhodnocovania výsledkov a registráciu modelov (body 5, resp. 6) alebo pridáte verzovanie datasetov, prípadne niečo iné? Pointa, ktorú som sa snažil povedať, je, že potrebujete MLOps ako celok, MLflow je len prostriedok na dosiahnutie cieľa.

Napíšte, s akými problémami ste sa stretli, ktoré som nezobrazil?
Čo by ste pridali do systému, aby vyhovoval vašim potrebám?
Aké nástroje a prístupy používate na vyriešenie všetkých problémov alebo ich časti?

PS nechám pár odkazov:
projekt github - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Môj pracovný e-mail pre otázky - [chránené e-mailom]

Naša spoločnosť pravidelne organizuje rôzne podujatia pre IT špecialistov, napr.: 8. júla o 19:00 moskovského času sa uskutoční CV meetup v online formáte, v prípade záujmu sa môžete zúčastniť, registrácia tu .

Zdroj: hab.com

MLOps – Kuchárska kniha, kapitola 1