MLOps – Szakácskönyv, 1. fejezet

Sziasztok! CV fejlesztő vagyok a CROC-nál. Immár 3 éve valósítunk meg projekteket önéletrajz területén. Ez idő alatt sok mindent csináltunk, például: figyeltük a sofőröket, hogy vezetés közben ne igyanak, ne dohányozzanak, ne beszéljenek telefonon, az utat nézzék, és ne az álmokat vagy a felhőket. ; Rögzítettük azokat az embereket, akik kijelölt sávban közlekednek és több parkolóhelyet foglalnak el; gondoskodott arról, hogy a dolgozók sisakot, kesztyűt stb. viseljenek; azonosított egy alkalmazottat, aki be akar lépni a létesítménybe; Mindent megszámoltunk, amit lehetett.

Minek csinálom ezt az egészet?

A projektek megvalósítása során ütközésekbe ütközünk, sok zökkenőt, néhány olyan problémát, amelyeket Ön vagy ismer, vagy a jövőben megismerni fog.

A helyzet modellezése

Képzeljük el, hogy egy fiatal „N” cégnél kaptunk munkát, amelynek tevékenysége az ML-hez kapcsolódik. Dolgozunk egy ML (DL, CV) projekten, majd valamilyen oknál fogva másik munkára váltunk, általában szünetet tartunk, és visszatérünk a saját vagy valaki más neuronjához.

1. Eljön az igazság pillanata, valahogy emlékezned kell arra, hogy hol álltál meg, milyen hiperparaméterekkel próbálkoztál, és ami a legfontosabb, milyen eredményekhez vezettek. Számos lehetőség közül választhat, hogy ki tárolt információkat az összes indításkor: fejben, konfigurációkban, jegyzettömbben, munkakörnyezetben a felhőben. Véletlenül láttam olyan opciót, amikor a hiperparamétereket kommentált sorokként tárolták a kódban, általában csak úgy képzeletben. Most képzeld el, hogy nem a saját projektedhez tértél vissza, hanem egy olyan személy projektjéhez, aki elhagyta a céget, és örököltél egy modell_1.pb nevű kódot és modellt. A kép teljessé tételéhez és a fájdalom átadásához képzeljük el, hogy Ön is kezdő szakember.
2. Menj tovább. A kód futtatásához nekünk és mindenkinek, aki dolgozni fog vele, létre kell hoznunk egy környezetet. Gyakran előfordul, hogy valamiért nem hagyták őt örökségünknek. Ez is nem triviális feladattá válhat. Ugye nem akarsz időt vesztegetni erre a lépésre?
3. Betanítunk egy modellt (például egy autódetektort). Elérkeztünk arra a pontra, ahol nagyon jó lesz – ideje menteni az eredményt. Nevezzük ezt car_detection_v1.pb-nek. Ezután betanítunk egy másikat - car_detection_v2.pb. Egy idő után kollégáink vagy mi magunk is egyre többet tanítunk, különböző architektúrákat használva. Ennek eredményeként egy csomó lelet keletkezik, amelyekről alaposan össze kell gyűjteni az információkat (de ezt később fogjuk megtenni, mert most fontosabb ügyeink vannak).
4. Rendben, most mindennek vége! Van modellünk! Elkezdhetjük a következő modell betanítását, egy architektúra fejlesztését egy új probléma megoldására, vagy teázhatunk egyet? És ki fogja bevetni?

A problémák azonosítása

Egy projekten vagy terméken való munka sok ember munkája. És idővel az emberek elmennek és jönnek, több projekt van, és maguk a projektek is bonyolultabbá válnak. Így vagy úgy, a fent leírt ciklus helyzetei (és nem csak) bizonyos kombinációkban iterációról iterációra fordulnak elő. Mindez elvesztegetett időt, zűrzavart, idegességet, esetleg vásárlói elégedetlenséget, és végső soron pénzkiesést eredményez. Bár általában mindannyian ugyanazt a régi gereblyét követjük, úgy gondolom, hogy senki sem akarja újra és újra átélni ezeket a pillanatokat.

Tehát egy fejlesztési cikluson mentünk keresztül, és azt látjuk, hogy vannak megoldandó problémák. Ehhez szüksége van:

• kényelmesen tárolja a munkaeredményeket;
• egyszerűsítse az új alkalmazottak bevonásának folyamatát;
• a fejlesztői környezet telepítési folyamatának egyszerűsítése;
• konfigurálja a modell verziószámítási folyamatát;
• kényelmes módja van a modellek érvényesítésének;
• modellállapot-kezelési eszközt találni;
• megtalálja a módját a modellek gyártásba szállításának.

Nyilvánvalóan olyan munkafolyamatot kell kidolgozni, amely lehetővé tenné ennek az életciklusnak az egyszerű és kényelmes kezelését? Ezt a gyakorlatot MLOps-nak nevezik

Az MLOps vagy DevOps a gépi tanuláshoz lehetővé teszi az adattudományi és informatikai csapatok számára, hogy együttműködjenek, és növeljék a modellfejlesztés és -telepítés ütemét a gépi tanulási modellek monitorozása, érvényesítése és irányítása révén.

Képes olvasniMit gondolnak minderről a Google-fiúk? A cikkből kiderül, hogy az MLOps elég terjedelmes dolog.

A továbbiakban cikkemben a folyamatnak csak egy részét írom le. A megvalósításhoz az MLflow eszközt fogom használni, mert... Ez egy nyílt forráskódú projekt, kis mennyiségű kódra van szükség a csatlakozáshoz, és van integráció a népszerű ml-keretrendszerekkel. Kereshet az interneten más eszközöket, mint például a Kubeflow, a SageMaker, a Trains stb., és talán megtalálja az igényeinek jobban megfelelőt.

MLOp-ok „építése” az MLFlow eszköz példájával

Az MLFlow egy nyílt forráskódú platform az ml modellek életciklus-kezeléséhez (https://mlflow.org/).

Az MLflow négy összetevőből áll:

• MLflow Tracking – lefedi az eredmények rögzítésének és az ehhez az eredményhez vezető paramétereknek a kérdéseit;
• MLflow Project - lehetővé teszi a kód becsomagolását és reprodukálását bármilyen platformon;
• MLflow modellek – felelős a modellek üzembe helyezéséért a termelésben;
• MLflow Registry – lehetővé teszi modellek tárolását és állapotuk kezelését egy központi tárolóban.

Az MLflow két entitáson működik:

• a start egy teljes képzési ciklus, paraméterek és mérőszámok, amelyek alapján regisztrálni szeretnénk;
• A kísérlet egy „téma”, amely együtt fut.

A példa minden lépése az Ubuntu 18.04 operációs rendszeren van megvalósítva.

1. Telepítse a kiszolgálót

Annak érdekében, hogy könnyedén kezelhessük projektünket és minden szükséges információt megkapjunk, szervert telepítünk. Az MLflow nyomkövető szervernek két fő összetevője van:

• háttértár – a regisztrált modellek információinak tárolásáért felelős (4 DBMS-t támogat: mysql, mssql, sqlite és postgresql);
• artifact store – a műtermékek tárolásáért felelős (7 tárolási lehetőséget támogat: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP szerver, SFTP szerver, NFS, HDFS).

Mivel a műtárgy bolt Az egyszerűség kedvéért vegyünk egy sftp szervert.

• hozzon létre egy csoportot

  $ sudo groupadd sftpg

• adjunk hozzá egy felhasználót, és állítsunk be neki egy jelszót

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• néhány hozzáférési beállítás módosítása

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

• adjunk hozzá néhány sort az /etc/ssh/sshd_config fájlhoz

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

• indítsa újra a szolgáltatást

  $ sudo systemctl restart sshd

Mivel a háttéráruház Vegyük a postgresql-t.

$ 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

A szerver indításához telepítenie kell a következő python csomagokat (javaslom egy külön virtuális környezet létrehozását):

pip install mlflow
pip install pysftp

Indítsuk el a szerverünket

$ 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. Nyomon követés hozzáadása

Annak érdekében, hogy képzésünk eredményei ne vesszenek el, a jövő fejlesztői nemzedékei megértsék, mi történik, és hogy az idősebb elvtársak és Ön nyugodtan elemezhessük a tanulási folyamatot, nyomkövetést kell hozzáadnunk. A követés a paraméterek, mérőszámok, műtermékek és a képzés kezdetével kapcsolatos további információk elmentését jelenti esetünkben a szerverre.

Például létrehoztam egy kicsi projekt a githubon a Kerason, hogy szegmentálja mindazt, ami benne van COCO adatkészlet. A nyomkövetés hozzáadásához létrehoztam egy mlflow_training.py fájlt.

Itt vannak azok a sorok, ahol a legérdekesebb dolgok történnek:

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)

Itt a self.remote_server egy kis wrapper az mlflow.tracking metódusok felett. MlflowClient (a kényelem kedvéért készítettem), aminek segítségével létrehozok egy kísérletet és futtatom a szerveren. Ezután megjelölöm, hogy az indítási eredményeket hol kell egyesíteni (mlflow.set_tracking_uri(self.tracking_uri)). Engedélyeztem az automatikus naplózást az mlflow.keras.autolog(). Jelenleg az MLflow Tracking támogatja a TensorFlow, Keras, Gluon XGBoost, LightGBM és Spark automatikus naplózását. Ha nem találta meg a keretrendszert vagy a könyvtárat, bármikor bejelentkezhet kifejezetten. Kezdjük az edzést. Regisztráljon címkéket és beviteli paramétereket a távoli szerveren.

Néhány sor, és mindenki máshoz hasonlóan hozzáférhet az összes indulással kapcsolatos információhoz. Menő?

3. Elkészítjük a projektet

Most tegyük egyszerűvé a projekt elindítását. Ehhez adja hozzá az MLproject és a conda.yaml fájlt a projekt gyökérkönyvtárához.
MLproject

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

Az MLflow Project számos tulajdonsággal rendelkezik:

• Név – a projekt neve;
• Környezet – esetemben a conda_env azt jelzi, hogy az Anaconda fut, és a függőségi leírás a conda.yaml fájlban található;
• Entry Points - jelzi, hogy mely fájlokat és milyen paraméterekkel tudjuk futtatni (az edzés megkezdésekor minden paraméter automatikusan naplózásra kerül)

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

A dockert futtatókörnyezetként használhatja, további részletekért lásd: dokumentáció.

4. Kezdjük az edzést

Klónozzuk a projektet, és belépünk a projektkönyvtárba:

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

A futtatáshoz könyvtárakat kell telepítenie

pip install mlflow
pip install pysftp

Mert a conda_env-t használom példában az Anacondát telepíteni kell a számítógépedre (de ezt megkerülheted, ha magad telepíted az összes szükséges csomagot és játszol az indítási paraméterekkel).

Minden előkészítő lépés megtörtént, és megkezdhetjük a képzés elindítását. A projekt gyökérből:

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

A parancs beírása után automatikusan létrejön egy conda környezet és elindul a képzés.
A fenti példában átadtam a képzési korszakok számát, azokat a kategóriákat, amelyekbe szeretnénk szegmentálni (a teljes listát láthatja itt) és távoli szerverünk címét.
A lehetséges paraméterek teljes listája az MLproject fájlban található.

5. Értékelje a tanulási eredményeket

A képzés elvégzése után a böngészőben mehetünk a szerverünk címére http://server_host:server_port

Itt láthatjuk az összes kísérlet listáját (bal felső sarokban), valamint a futtatásokkal kapcsolatos információkat (középen). Részletesebb információkat (paraméterek, mérőszámok, műtermékek és néhány további információ) tekinthetünk meg minden egyes elindításhoz.

Minden mérőszámnál megfigyelhetjük a változások történetét

Azok. Jelenleg „manuális” módban tudjuk elemezni az eredményeket, illetve az MLflow API segítségével automatikus érvényesítést is beállíthatunk.

6. Regisztrálja a modellt

Miután elemeztük a modellünket, és úgy döntöttünk, hogy készen áll a harcra, folytatjuk a regisztrálást, ehhez kiválasztjuk a szükséges indítást (ahogyan az előző bekezdésben is látható), és lefelé megyünk.

Miután nevet adtunk a modellünknek, van egy verziója. Ha másik modellt ment el ugyanazzal a névvel, a verzió automatikusan frissítésre kerül.

Mindegyik modellhez hozzáadhatunk leírást és kiválaszthatunk egyet a három állapot közül (Staging, Production, Archived), majd az API segítségével elérhetjük ezeket az állapotokat, ami a verziószámmal együtt további rugalmasságot biztosít.

Ezenkívül minden modellhez könnyen hozzáférünk

és azok változatai

Az előző bekezdéshez hasonlóan minden művelet elvégezhető az API használatával.

7. Telepítse a modellt

Ebben a szakaszban már van egy betanított (keras) modellünk. Egy példa a használatára:

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

Itt a self.registry ismét egy kis wrapper az mlflow.tracking.MlflowClient felett, a kényelem kedvéért. A lényeg, hogy elérek egy távoli szervert, és ott keresek egy modellt a megadott néven, és a legújabb éles verzióval. Ezután letöltöm a mellékterméket helyileg a ./model mappába, és ebből a könyvtárból készítem el a modellt az mlflow.keras.load_model(local_path). Most már használhatjuk a modellünket. Az önéletrajz (ML) fejlesztői könnyedén javíthatják a modellt, és új verziókat tehetnek közzé.

Összefoglalva

Bemutattam egy rendszert, amely lehetővé teszi:

• központilag tárolja az információkat az ML modellekről, az edzés előrehaladásáról és az eredményekről;
• gyorsan telepíthet egy fejlesztői környezetet;
• figyelemmel kíséri és elemzi a modellekkel kapcsolatos munka előrehaladását;
• kényelmes a verziók és a modellek állapotának kezelése;
• Az így létrejött modellek telepítése egyszerű.

Ez a példa egy játék, és kiindulópontként szolgál saját rendszerének felépítéséhez, amely magában foglalhatja az eredmények kiértékelésének és a modellek regisztrálásának automatizálását (5. és 6. pont), vagy hozzáadja az adatkészletek verziószámát, vagy esetleg valami mást? Arra próbáltam rávilágítani, hogy az MLO-kra mint egészre van szükség, az MLflow csak egy eszköz a cél eléréséhez.

Írja meg, milyen problémákkal találkozott, amelyeket nem jelenítettem meg?
Mit adna hozzá a rendszerhez, hogy megfeleljen az Ön igényeinek?
Milyen eszközöket és megközelítéseket használ a problémák egy részének vagy egészének megoldására?

PS Hagyok pár linket:
github projekt - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Munkahelyi e-mail-címem kérdésekre - [e-mail védett]

Cégünk rendszeres időközönként különböző rendezvényeket szervez informatikusoknak, pl.: július 8-án moszkvai idő szerint 19:00-kor önéletrajz-találkozó lesz online formátumban, ha felkeltettük érdeklődését, részt vehet, regisztráció itt .

Forrás: will.com