MLOps – kokaraamat, 1. peatükk

Tere kõigile! Olen CV arendaja ettevõttes CROC. Oleme CV valdkonna projekte ellu viinud nüüdseks 3 aastat. Selle aja jooksul tegime palju asju, näiteks: jälgisime juhte, et nad roolis ei jooks, ei suitsetaks, ei räägiks telefoniga, ei vaataks teed, mitte unenägusid ega pilvi. ; Salvestasime inimesed, kes sõidavad selleks ettenähtud radadel ja hõivavad mitu parkimiskohta; tagas, et töötajad kannaksid kiivreid, kindaid jne; tuvastas töötaja, kes soovib objekti siseneda; Lugesime kõik üle, mis suutsime.

Milleks ma seda kõike teen?

Projektide elluviimise käigus tabab meid konarusi, palju konarusi, mõningaid probleeme, mis on teile tuttavad või tulevikus tuttavad.

Simuleerime olukorda

Kujutagem ette, et saime tööd noores firmas “N”, mille tegevus on seotud ML-ga. Töötame ML (DL, CV) projekti kallal, seejärel läheme mingil põhjusel teisele tööle, teeme üldiselt pausi ja pöördume tagasi enda või kellegi teise neuroni juurde.

1. Tõehetk saabub, peate kuidagi meeles pidama, kus peatusite, milliseid hüperparameetreid proovisite ja mis kõige tähtsam, milliste tulemusteni need viisid. Selle jaoks, kes salvestas teabe kõigi käivitamiste kohta, võib olla palju võimalusi: peas, konfiguratsioonides, märkmikus, töökeskkonnas pilves. Juhtusin nägema võimalust, kui hüperparameetrid salvestati koodis kommenteeritud ridadena, üldiselt on see fantastiline lend. Kujutage nüüd ette, et te ei pöördunud tagasi mitte oma projekti, vaid ettevõttest lahkunud inimese projekti juurde ja pärisite koodi ja mudeli nimega model_1.pb. Pildi täiendamiseks ja valu edasi andmiseks kujutage ette, et olete ka algaja spetsialist.
2. Lase käia. Koodi käitamiseks peame meie ja kõik, kes sellega töötavad, looma keskkonna. Tihti juhtub, et nad ei jätnud teda mingil põhjusel meie pärandiks. Sellest võib saada ka mittetriviaalne ülesanne. Sa ei taha sellele sammule aega raisata, eks?
3. Koolitame modelli (näiteks autodetektorit). Jõuame punktini, kus see muutub väga heaks – on aeg tulemus salvestada. Nimetagem seda car_detection_v1.pb-ks. Seejärel treenime veel ühe - car_detection_v2.pb. Mõni aeg hiljem õpetavad meie kolleegid või meie ise üha rohkem, kasutades erinevaid arhitektuure. Selle tulemusena moodustub hunnik artefakte, mille kohta teavet tuleb hoolikalt koguda (aga teeme seda hiljem, sest praegu on meil prioriteetsemad asjad).
4. OK, nüüd on kõik läbi! Meil on modell! Kas saame hakata koolitama järgmist mudelit, välja töötama uue probleemi lahendamiseks arhitektuuri või võiksime minna teed jooma? Ja kes kasutusele võtab?

Probleemide tuvastamine

Projekti või toote kallal töötamine on paljude inimeste töö. Ja aja jooksul inimesed lahkuvad ja tulevad, projekte tuleb juurde ja projektid ise muutuvad keerulisemaks. Ühel või teisel viisil ilmnevad olukorrad ülalkirjeldatud tsüklist (ja mitte ainult) teatud kombinatsioonides iteratsioonist iteratsiooni. Kõik see toob kaasa raisatud aja, segaduse, närvid, võib-olla klientide rahulolematuse ja lõpuks raha kaotamise. Kuigi me kõik järgime tavaliselt sama vana reha, usun, et keegi ei taha neid hetki ikka ja jälle uuesti läbi elada.

Seega oleme ühe arendustsükli läbinud ja näeme, et on probleeme, mis vajavad lahendamist. Selleks vajate:

• salvestada mugavalt töötulemusi;
• muuta uute töötajate kaasamise protsess lihtsaks;
• lihtsustada arenduskeskkonna juurutamise protsessi;
• konfigureerida mudeli versioonide loomise protsess;
• omama mugavat võimalust mudelite valideerimiseks;
• leida näidisriigi juhtimise tööriist;
• leida viis mudelite tootmisse tarnimiseks.

Ilmselt on vaja välja mõelda töövoog, mis võimaldaks seda elutsüklit lihtsalt ja mugavalt hallata? Seda praktikat nimetatakse MLOks

MLOps ehk masinõppe DevOps võimaldab andmeteaduse ja IT-meeskondadel teha koostööd ning suurendada mudelite arendamise ja juurutamise tempot masinõppemudelite jälgimise, valideerimise ja juhtimise kaudu.

Võite loeMida Google'i poisid sellest kõigest arvavad? Artiklist selgub, et MLOps on üsna mahukas asi.

Edasi kirjeldan oma artiklis ainult osa protsessist. Rakendamiseks kasutan MLflow tööriista, sest... See on avatud lähtekoodiga projekt, ühenduse loomiseks on vaja väikest kogust koodi ja see on integreeritud populaarsete ml-raamistikega. Saate Internetist otsida muid tööriistu, nagu Kubeflow, SageMaker, Trains jne, ja võib-olla leida oma vajadustele paremini sobiva.

MLO-de "ehitamine" MLFlow tööriista kasutamise näitel

MLFlow on avatud lähtekoodiga platvorm ml mudelite elutsükli haldamiseks (https://mlflow.org/).

MLflow sisaldab nelja komponenti:

• MLflow Tracking – hõlmab tulemuste ja parameetrite salvestamise küsimusi, mis selle tulemuseni viisid;
• MLflow Project – võimaldab koodi pakendada ja reprodutseerida mis tahes platvormil;
• MLflow mudelid – vastutab mudelite tootmisse juurutamise eest;
• MLflow register – võimaldab salvestada mudeleid ja hallata nende olekut tsentraliseeritud hoidlas.

MLflow töötab kahel olemil:

• käivitamine on koolituste, parameetrite ja mõõdikute täielik tsükkel, mille alusel soovime registreeruda;
• Katse on „teema”, mis jookseb koos.

Kõik näite sammud on rakendatud operatsioonisüsteemis Ubuntu 18.04.

1. juurutage server

Selleks, et saaksime oma projekti hõlpsalt hallata ja kogu vajaliku teabe kätte saada, võtame kasutusele serveri. MLflow jälgimisserveril on kaks põhikomponenti:

• taustapood – vastutab registreeritud mudelite teabe salvestamise eest (toetab 4 DBMS-i: mysql, mssql, sqlite ja postgresql);
• artefaktide pood – vastutab artefaktide salvestamise eest (toetab 7 salvestusvõimalust: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP server, SFTP server, NFS, HDFS).

Kuna esemete pood Lihtsuse huvides võtame sftp-serveri.

• luua grupp

  $ sudo groupadd sftpg

• lisage kasutaja ja määrake talle parool

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• paari juurdepääsuseadete reguleerimine

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

• lisage faili /etc/ssh/sshd_config paar rida

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

• taaskäivitage teenus

  $ sudo systemctl restart sshd

Kuna taustapood Võtame postgresqli.

$ 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

Serveri käivitamiseks peate installima järgmised pythoni paketid (soovitan luua eraldi virtuaalse keskkonna):

pip install mlflow
pip install pysftp

Käivitame oma serveri

$ 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. Lisa jälgimine

Selleks, et meie koolituse tulemused kaotsi ei läheks, tulevased arendajate põlvkonnad mõistaksid toimuvat ning et vanemad kamraadid saaksid rahulikult õppeprotsessi analüüsida, peame lisama jälgimise. Jälgimine tähendab parameetrite, mõõdikute, artefaktide ja igasuguse koolituse alguse kohta lisateabe salvestamist meie puhul serverisse.

Näiteks lõin väikese projekt githubis Keras, et segmenteerida kõike, mis sees on COCO andmestik. Jälgimise lisamiseks lõin faili mlflow_training.py.

Siin on read, kus kõige huvitavamad asjad juhtuvad:

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)

Siin self.remote_server on mlflow.tracking meetodite väike ümbris. MlflowClient (tegin selle mugavuse pärast), mille abil koostan katse ja käivitan selle serveris. Järgmisena näitan, kuhu käivitamistulemused ühendada (mlflow.set_tracking_uri(self.tracking_uri)). Luban automaatse logimise mlflow.keras.autolog(). Praegu toetab MLflow Tracking automaatset logimist TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark jaoks. Kui te pole oma raamistikku või teeki leidnud, saate alati selgelt sisse logida. Alustame treeningutega. Registreerige sildid ja sisendparameetrid kaugserveris.

Paar rida ja teil, nagu kõigil teistel, on juurdepääs teabele kõigi käivitamiste kohta. Lahe?

3. Koostame projekti

Teeme nüüd projekti käivitamise lihtsaks. Selleks lisa projekti juure failid MLproject ja conda.yaml.
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}"

MLflow projektil on mitu atribuuti:

• Nimi - teie projekti nimi;
• Keskkond – minu puhul näitab conda_env, et töötamiseks kasutatakse Anacondat ja sõltuvuse kirjeldus on failis conda.yaml;
• Entry Points - näitab, milliseid faile ja milliste parameetritega saame käivitada (kõik parameetrid logitakse automaatselt treeningu alustamisel)

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

Saate kasutada dokkerit oma käituskeskkonnana, lisateabe saamiseks vaadake dokumentatsioon.

4. Alustame treeningutega

Kloonime projekti ja läheme projekti kataloogi:

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

Käivitamiseks peate installima teegid

pip install mlflow
pip install pysftp

Sest näites kasutan conda_env, peab Anaconda arvutisse installitud olema (aga sellest saate mööda, kui installite kõik vajalikud paketid ise ja mängite käivitusparameetritega).

Kõik ettevalmistusetapid on tehtud ja saame alustada koolitust. Projekti juurtest:

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

Pärast käsu sisestamist luuakse automaatselt conda keskkond ja koolitus algab.
Ülaltoodud näites läbisin koolituse epohhide arvu, kategooriad, millesse tahame segmenteerida (näete täielikku loendit siin) ja meie kaugserveri aadress.
Võimalike parameetrite täieliku loendi leiate failist MLproject.

5. Hinda õpitulemusi

Pärast koolituse läbimist saame brauseris minna oma serveri aadressile http://server_host:server_port

Siin näeme kõigi katsete loendit (vasakul ülaosas) ja teavet käituste kohta (keskel). Iga käivitamise kohta saame vaadata üksikasjalikumat teavet (parameetrid, mõõdikud, artefaktid ja mõningane lisateave).

Iga mõõdiku puhul saame jälgida muutuste ajalugu

Need. Hetkel saame tulemusi analüüsida “käsitsi” režiimis, samuti saab seadistada automaatse valideerimise MLflow API abil.

6. Registreerige mudel

Kui oleme oma mudelit analüüsinud ja otsustanud, et see on lahinguks valmis, jätkame selle registreerimist, selleks valime vajaliku käivituse (nagu on näidatud eelmises lõigus) ja läheme alla.

Kui oleme oma mudelile nime andnud, on sellel versioon. Kui salvestate teise mudeli sama nimega, uuendatakse versiooni automaatselt.

Iga mudeli jaoks saame lisada kirjelduse ja valida ühe kolmest olekust (Staging, Production, Archived); seejärel pääseme API abil neile olekutele juurde, mis koos versioonide loomisega annab täiendavat paindlikkust.

Meil on ka lihtne juurdepääs kõikidele mudelitele

ja nende versioonid

Nagu eelmises lõigus, saab kõiki toiminguid teha API abil.

7. Mudeli juurutamine

Selles etapis on meil juba koolitatud (keras) mudel. Näide selle kasutamise kohta:

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

Siin on self.registry mugavuse huvides jällegi väike ümbris mlflow.tracking.MlflowClient peal. Asi on selles, et ma pöördun kaugserveri poole ja otsin sealt mudelit, millel on määratud nimi ja uusim tootmisversioon. Järgmiseks laadin artefakti lokaalselt alla kausta ./model ja koostan mudeli sellest kataloogist mlflow.keras.load_model(local_path). Nüüd saame oma mudelit kasutada. CV (ML) arendajad saavad mudelit hõlpsalt täiustada ja uusi versioone avaldada.

Kokkuvõttes

Esitasin süsteemi, mis võimaldab:

• salvestada tsentraalselt teavet ML mudelite, treeningute edenemise ja tulemuste kohta;
• kiiresti arenduskeskkonda juurutada;
• jälgida ja analüüsida mudelitega tehtava töö edenemist;
• mudelite olekut on mugav versioonida ja hallata;
• Saadud mudeleid on lihtne juurutada.

See näide on mänguasi ja see on lähtepunktiks oma süsteemi loomisel, mis võib hõlmata tulemuste hindamise ja mudelite registreerimise automatiseerimist (vastavalt punktid 5 ja 6) või lisate andmekogumite versioonide või võib-olla midagi muud? Püüdsin öelda, et vajate MLO-sid tervikuna, MLflow on vaid vahend eesmärgi saavutamiseks.

Kirjutage, milliste probleemidega te kokku puutusite, mida ma ei kuvanud?
Mida lisaksite süsteemi, et see vastaks teie vajadustele?
Milliseid vahendeid ja lähenemisviise kasutate probleemide või osade lahendamiseks?

PS jätan paar linki:
githubi projekt - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Minu töömeil küsimuste jaoks - [meiliga kaitstud]

Meie ettevõttes toimub perioodiliselt erinevaid IT-spetsialistidele suunatud üritusi, näiteks: 8. juulil kell 19:00 Moskva aja järgi toimub CV kohtumine online formaadis, huvi korral saab osa võtta, registreerimine siin .

Allikas: www.habr.com