MLOps - Kuchařka, kapitola 1

Ahoj všichni! Jsem CV developer ve společnosti CROC. Projekty v oblasti CV realizujeme již 3. rokem. Během této doby jsme dělali spoustu věcí, například: monitorovali jsme řidiče, aby při jízdě nepili, nekouřili, netelefonovali, nedívali se na silnici a ne do snů nebo do mraků ; Zaznamenali jsme lidi, kteří jezdí ve vyhrazených pruzích a zabírají několik parkovacích míst; zajistit, aby pracovníci nosili přilby, rukavice atd.; identifikovat zaměstnance, který chce vstoupit do zařízení; Spočítali jsme všechno, co se dalo.

Proč to všechno dělám?

V procesu realizace projektů narážíme na hrboly, na spoustu problémů, na některé problémy, které buď znáte, nebo se s nimi v budoucnu seznámíte.

Simulujeme situaci

Představme si, že jsme získali práci v mladé společnosti „N“, jejíž aktivity souvisejí s ML. Pracujeme na projektu ML (DL, CV), pak z nějakého důvodu přejdeme na jinou práci, obecně si dáme pauzu a vrátíme se na svůj nebo cizí neuron.

1. Přichází okamžik pravdy, je potřeba si nějak zapamatovat, kde jste se zastavili, jaké hyperparametry jste zkoušeli a hlavně k jakým výsledkům vedly. Možností, kdo ukládal informace o všech spuštěních, může být mnoho: v hlavě, konfiguracích, poznámkovém bloku, v pracovním prostředí v cloudu. Náhodou jsem viděl možnost, když byly hyperparametry uloženy jako komentované řádky v kódu, obecně vzato, fantazie. Nyní si představte, že jste se nevrátili ke svému projektu, ale k projektu člověka, který z firmy odešel a vy jste zdědili kód a model s názvem model_1.pb. Abychom doplnili obrázek a přenesli všechnu bolest, představme si, že jste také začínající specialista.
2. Pokračuj. Pro spuštění kódu potřebujeme my a všichni, kdo s ním budou pracovat, vytvořit prostředí. Často se stává, že ho z nějakého důvodu nezanechali jako naše dědictví. I to se může stát netriviálním úkolem. Nechcete tímto krokem ztrácet čas, že?
3. Trénujeme model (například detektor aut). Dostáváme se do bodu, kdy to bude velmi dobré – je čas uložit výsledek. Říkejme tomu car_detection_v1.pb. Poté trénujeme další - car_detection_v2.pb. O něco později naši kolegové nebo my sami vyučujeme více a více pomocí různých architektur. Výsledkem je, že se vytvoří hromada artefaktů, o kterých je třeba pečlivě shromažďovat informace (ale to uděláme později, protože prozatím máme více prioritních záležitostí).
4. Dobře, teď je po všem! Máme modelku! Můžeme začít trénovat další model, vyvíjet architekturu k vyřešení nového problému, nebo si můžeme jít dát čaj? A kdo nasadí?

Identifikace problémů

Práce na projektu nebo produktu je práce mnoha lidí. A postupem času lidé odcházejí a přicházejí, projektů je více a projekty samotné jsou složitější. Tak či onak, situace z výše popsaného cyklu (nejen) v určitých kombinacích nastanou od iterace k iteraci. To vše má za následek promarněný čas, zmatek, nervy, možná nespokojenost zákazníků a nakonec i ztracené peníze. I když se všichni většinou řídíme stejně starými hráběmi, věřím, že nikdo nechce tyto okamžiky prožívat znovu a znovu.

Takže jsme prošli jedním vývojovým cyklem a vidíme, že existují problémy, které je třeba vyřešit. K tomu potřebujete:

• pohodlně ukládat výsledky práce;
• zjednodušit proces zapojování nových zaměstnanců;
• zjednodušit proces nasazení vývojového prostředí;
• nakonfigurovat proces verzování modelu;
• mít pohodlný způsob ověřování modelů;
• najít modelový nástroj řízení stavu;
• najít způsob, jak dodat modely do výroby.

Zřejmě je nutné vymyslet pracovní postup, který by vám umožnil tento životní cyklus snadno a pohodlně řídit? Tato praxe se nazývá MLOps

MLOps nebo DevOps pro strojové učení umožňuje týmům datové vědy a IT spolupracovat a zvýšit tempo vývoje a nasazení modelů prostřednictvím monitorování, ověřování a správy modelů strojového učení.

Můžete čestCo si o tom všem myslí pánové z Googlu? Z článku je jasné, že MLOps je docela objemná věc.

Dále ve svém článku popíšu pouze část procesu. Pro implementaci použiji nástroj MLflow, protože... Jedná se o projekt s otevřeným zdrojovým kódem, pro připojení je vyžadováno malé množství kódu a existuje integrace s populárními rámci ml. Můžete hledat na internetu další nástroje, jako je Kubeflow, SageMaker, Trains atd., a možná najít ten, který lépe vyhovuje vašim potřebám.

„Building“ MLOps pomocí příkladu použití nástroje MLFlow

MLFlow je open source platforma pro správu životního cyklu modelů ml (https://mlflow.org/).

MLflow obsahuje čtyři komponenty:

• MLflow Tracking - pokrývá problematiku zaznamenávání výsledků a parametrů, které k tomuto výsledku vedly;
• MLflow Project - umožňuje zabalit kód a reprodukovat jej na jakékoli platformě;
• Modely MLflow – odpovědné za nasazení modelů do výroby;
• MLflow Registry – umožňuje ukládat modely a spravovat jejich stav v centralizovaném úložišti.

MLflow funguje na dvou entitách:

• spuštění je úplný cyklus školení, parametrů a metrik, podle kterých se chceme registrovat;
• Experiment je „téma“, které běží společně.

Všechny kroky příkladu jsou implementovány na operačním systému Ubuntu 18.04.

1. Nasaďte server

Abychom mohli náš projekt snadno spravovat a dostávat všechny potřebné informace, nasadíme server. Sledovací server MLflow má dvě hlavní součásti:

• backend store - zodpovědný za ukládání informací o registrovaných modelech (podporuje 4 DBMS: mysql, mssql, sqlite a postgresql);
• Artifact store – odpovídá za ukládání artefaktů (podporuje 7 možností úložiště: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP server, SFTP Server, NFS, HDFS).

Vzhledem k tomu, obchod s artefakty Pro jednoduchost si vezměme sftp server.

• vytvořit skupinu

  $ sudo groupadd sftpg

• přidat uživatele a nastavit mu heslo

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• upravit několik nastavení přístupu

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

• přidejte několik řádků do /etc/ssh/sshd_config

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

• restartujte službu

  $ sudo systemctl restart sshd

Vzhledem k tomu, backendový obchod Vezměme 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

Chcete-li spustit server, musíte nainstalovat následující balíčky python (doporučuji vytvořit samostatné virtuální prostředí):

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. Přidejte sledování

Aby se výsledky našeho školení neztratily, budoucí generace vývojářů pochopily, co se dělo, a starší soudruzi a vy mohli v klidu analyzovat proces učení, musíme přidat sledování. Sledování znamená ukládání parametrů, metrik, artefaktů a jakýchkoli dalších informací o začátku tréninku, v našem případě, na server.

Vytvořil jsem například malý projekt na githubu na Kerasu pro segmentaci všeho, co je in COCO datový soubor. Pro přidání sledování jsem vytvořil soubor mlflow_training.py.

Zde jsou řádky, kde se dějí nejzajímavější věci:

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 zde malý obal nad metodami mlflow.tracking. MlflowClient (udělal jsem ho pro pohodlí), s jehož pomocí vytvořím experiment a spustím jej na serveru. Dále uvedu, kam by měly být výsledky spouštění sloučeny (mlflow.set_tracking_uri(self.tracking_uri)). Povoluji automatické protokolování mlflow.keras.autolog(). V současné době MLflow Tracking podporuje automatické protokolování pro TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Pokud jste nenašli svůj rámec nebo knihovnu, můžete se vždy explicitně přihlásit. Začínáme trénovat. Zaregistrujte značky a vstupní parametry na vzdáleném serveru.

Pár řádků a vy, stejně jako všichni ostatní, máte přístup k informacím o všech spuštěních. Chladný?

3. Vypracujeme projekt

Nyní si usnadníme spuštění projektu. Chcete-li to provést, přidejte soubor MLproject a conda.yaml do kořenového adresáře projektu.
ML projekt

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á několik vlastností:

• Název – název vašeho projektu;
• Prostředí – v mém případě conda_env označuje, že ke spuštění se používá Anaconda a popis závislosti je v souboru conda.yaml;
• Vstupní body - označuje, které soubory a s jakými parametry můžeme spustit (všechny parametry se automaticky zaznamenávají při zahájení tréninku)

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

Jako své běhové prostředí můžete použít docker, další podrobnosti naleznete na dokumentace.

4. Začněme trénovat

Naklonujeme projekt a přejdeme do adresáře projektu:

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

Pro spuštění je potřeba nainstalovat knihovny

pip install mlflow
pip install pysftp

Protože v příkladu, který používám conda_env, musí být Anaconda nainstalována na vašem počítači (ale můžete to obejít tak, že si sami nainstalujete všechny potřebné balíčky a pohrajete si s parametry spouštění).

Všechny přípravné kroky jsou hotové a můžeme začít s tréninkem. Z kořene projektu:

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

Po zadání příkazu se automaticky vytvoří prostředí conda a spustí se trénink.
Ve výše uvedeném příkladu jsem předal počet epoch pro školení, kategorie, do kterých chceme segmentovat (můžete vidět celý seznam zde) a adresu našeho vzdáleného serveru.
Kompletní seznam možných parametrů naleznete v souboru MLproject.

5. Hodnotit výsledky učení

Po dokončení školení můžeme přejít v prohlížeči na adresu našeho serveru http://server_host:server_port

Zde vidíme seznam všech experimentů (vlevo nahoře) a také informace o běhech (uprostřed). U každého spuštění můžeme zobrazit podrobnější informace (parametry, metriky, artefakty a některé další informace).

U každé metriky můžeme sledovat historii změn

Tito. V tuto chvíli můžeme analyzovat výsledky v „manuálním“ režimu a lze také nastavit automatickou validaci pomocí MLflow API.

6. Zaregistrujte model

Poté, co jsme analyzovali náš model a rozhodli jsme se, že je připraven k bitvě, přistoupíme k jeho registraci, k tomu vybereme start, který potřebujeme (jak je ukázáno v předchozím odstavci) a jdeme dolů.

Poté, co dáme našemu modelu jméno, má verzi. Pokud uložíte jiný model se stejným názvem, bude verze automaticky aktualizována.

Ke každému modelu můžeme přidat popis a vybrat jeden ze tří stavů (Staging, Production, Archived), následně pomocí API můžeme k těmto stavům přistupovat, což spolu s verzováním poskytuje další flexibilitu.

Máme také snadný přístup ke všem modelům

a jejich verze

Stejně jako v předchozím odstavci lze všechny operace provádět pomocí API.

7. Nasaďte model

V této fázi již máme natrénovaný (keras) model. Příklad, jak to můžete použít:

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

Zde self.registry je pro pohodlí opět malý obal nad mlflow.tracking.MlflowClient. Jde o to, že přistupuji na vzdálený server a hledám tam model se zadaným názvem a nejnovější produkční verzí. Dále stáhnu artefakt lokálně do složky ./model a sestavím model z tohoto adresáře mlflow.keras.load_model(local_path). Nyní můžeme použít náš model. Vývojáři CV (ML) mohou model snadno vylepšit a publikovat nové verze.

Konečně,

Představil jsem systém, který umožňuje:

• centrálně ukládat informace o modelech ML, průběhu a výsledcích školení;
• rychle nasadit vývojové prostředí;
• sledovat a analyzovat postup práce na modelech;
• je vhodné verzovat a spravovat stav modelů;
• Výsledné modely je snadné nasadit.

Tento příklad je hračka a slouží jako výchozí bod pro stavbu vlastního systému, který může zahrnovat automatizaci vyhodnocování výsledků a registraci modelů (bod 5, resp. 6) nebo přidáte verzování datových sad, případně něco jiného ? Pointa, kterou jsem se snažil udělat, je, že potřebujete MLOps jako celek, MLflow je jen prostředek k dosažení cíle.

Napište, na jaké problémy jste narazili, které jsem nezobrazil?
Co byste do systému přidali, aby vyhovoval vašim potřebám?
Jaké nástroje a přístupy používáte k řešení všech nebo části problémů?

PS nechám pár odkazů:
projekt github - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Můj pracovní email pro dotazy - [chráněno e-mailem]

Naše společnost pravidelně pořádá různé akce pro IT specialisty, např.: 8. července v 19:00 moskevského času proběhne CV meetup v online formátu, v případě zájmu se můžete zúčastnit, registrace zde .

Zdroj: www.habr.com