MLOps — retseptikogu, peatükk 1

Tere kõigile! Olen CV-arendaja KROKis. Oleme juba 3 aastat töötanud CV valdkonnas projektide elluviimisega. Selle aja jooksul oleme teinud erinevaid asju, näiteks: jälginud juhte, et nad sõidu ajal ei joovaks, ei suitsetaks, ei räägiks telefoniga, vaid vaataksid teed, mitte ei unustaks või vaataksid pilvi; fikseerinud inimesi, kes sõidavad eraldi sõiduradadel ja võtavad mitu parkimiskohta; jälginud, et töötajad kantaksid kiivreid, kindaid jne; tuvastanud töötajaid, kes soovivad objektile siseneda; arvestanud kõike, mida ainult saab.

Milleks ma seda räägin?

Projektide elluviimise käigus oleme kogunud teadmisi, palju teadmisi, ja mõne probleemiga olete võib-olla tuttav või tutvute nendega tulevikus.

Simuleerime olukorda

Kujutame ette, et tööle saime nooresse ettevõttesse “N”, mille tegevus on seotud ML-iga. Töötab meil ML (DL, CV) projektis, siis mingil põhjusel vahetame tööd, teeme pausi ja naaseme oma või kellegi teise närvivõrku.

1. Tuleb tõe hetk, peame kuidagi meenutama, millele me jäime, milliseid hüperparameetreid proovisime ja, mis kõige tähtsam, millistele tulemusele need viisid. Teavet võib olla mitmeid variante, kuidas inimesed on kogu informatsiooni käivitamise kohta säilitanud: peas, konfiguratsioonifailides, märkmikus või pilve töökeskkonnas. Olen näinud varianti, kus hüperparameetrid olid salvestatud kommenteeritud ridadena koodis, mis jättis ruumi loovusele. Ning nüüd kujutage ette, et olete tagasi mitte oma projekti juurde, vaid inimese projekti juurde, kes on ettevõtte juba lahkunud ja teile on jäänud kood ja mudel nimega model_1.pb. Täiendava konteksti ja kogu valu edastamiseks kujutame ette, et olete ka algaja spetsialist.
2. Jätkame. Koodi käivitamiseks peame ja kõik, kes sellega töötavad, peavad looma keskkonna. Tihti juhtub, et ka seda ei ole meile mingitel põhjustel pärandatud. See võib samuti osutuda keeruliseks ülesandeks. Selle sammu peale ei taha aega raisata, eks ole?
3. Koolitame mudelit (näiteks auto tuvastajat). Jõuame hetkeni, mil see hakkab päris hästi toimima — on aeg tulemus salvestada. Nimetame selle car_detection_v1.pb. Siis koolitame veel ühe — car_detection_v2.pb. Mõne aja pärast koolitame meie kolleegid või isegi meie veel ja veel, kasutades erinevaid arhitektuure. Lõpuks tekib hunnik artefakte, mille kohta tuleb teavet hoolikalt koguda (aga teeme seda hiljem, meil on ju hetkel tähtsamad asjad).
4. Nii et kõik on valmis! Meil on mudel! Saame alustada järgmise mudeli koolitamist, arendada arhitektuuri uue ülesande lahendamiseks või lähme teed jooma? Aga kes hakkab seda kasutusele võtma?

Tuletame probleemid esile

Projekti või toote kallal töötamine on paljude inimeste töö. Aja jooksul inimesed tulevad ja lähevad, projekte tekib järjest rohkem ning need muutuvad järjest keerulisemaks. Nii või teisiti võrdselt võib olla olukordi, nagu eelpool kirjeldatud tsüklis (ja mitte ainult), mis esinevad erinevates kombinatsioonides iga iteratsiooni jooksul. See kõik toob kaasa ajakulu, segaduse, närvikatkestusi, tõenäoliselt — tellija rahulolematust ja lõpuks — saamata jäänud raha. Kuigi me tavaliselt astume samadesse märkidesse, usun, et keegi ei taha pidevalt neid hetki uuesti läbi elada.

Nüüd, kui oleme läbinud ühe arendus-tsükli, näeme, et on probleeme, mida tuleb lahendada. Selleks on vaja:

• mugavalt salvestada töö tulemusi;
• teha uute töötajate kaasamisprotsess lihtsamaks;
• lihtsustada arenduskeskkonna käivitamise protsessi;
• seada mudelite versioonihaldusprotsess;
• omada mugavat meetodit mudelite valideerimiseks;
• leida mudelite oleku haldamise tööriist;
• leidma, kuidas mudelid tootmisse viia.

Tundub, et on vajalik välja mõelda töövoog, mis võimaldaks kergelt ja mugavalt hallata seda elutsüklit? Sellel praktikatel on nimi MLOps.

MLOps, ehk DevOps masinõppe jaoks, võimaldab andmete töötlemise ja analüüsi spetsialistide ning IT-ekspertide meeskondadel koostööd teha ning kiirendada mudelite arendamist ja juurutamist, kasutades jälgimist, kontrolli ja haldussüsteemi masinõppe mudelite jaoks.

Saate lugeda, mida sellest arvavad Google'i kutid. Artiklist on selge, et MLOps on üsna mahukas teema.

Edasi oma artiklis kirjeldan vaid osa protsessist. Rakendamiseks kasutan tööriista MLflow, kuna see on avatud lähtekoodiga projekt, mis vajab liitmiseks vaid väikest koodijuppi ning sellel on integraatsioon populaarsete ML-raamistikega. Te võite internetist otsida ka teisi tööriistu, näiteks Kubeflow, SageMaker, Trains jms, ja võib-olla leiate selle, mis sobib teie vajadustele paremini.

"Ehitatud" MLOps tööriista MLFlow kasutamise näitel

MLFlow on avatud lähtekoodiga platvorm ML mudelite elu tsükli haldamiseks (https://mlflow.org/).

MLflow sisaldab nelja komponenti:

• MLflow Tracking — lahendab tulemuste ja nende saavutamiseks kasutatud parameetrite registreerimise küsimusi;
• MLflow Project — võimaldab koodi pakkida ja seda igasugusel platvormil uuesti käivitada;
• MLflow Models — vastutab mudelite tootmisse viimise eest;
• MLflow Registry — võimaldab salvestada mudeleid ja hallata nende olekuid tsentraliseeritud hoidlas.

MLflow tegeleb kahe üksusega:

• käivitamine — see on kogu koolitusprotsess, parameetrid ja näitajad, mida soovime registreerida;
• eksperiment — see on "teema", mille alla on koondatud käivitused.

Kogu näite sammust on rakendatud operatiivsel süsteemil Ubuntu 18.04.

1. Kätkeme server

Selleks, et saaksime oma projekti hõlpsalt hallata ja kogu vajaliku teabe kätte saada, käivitame serveri. MLflow jälgimisserveril on kaks peamist komponenti:

• backend store — vastutab registreeritud mudelite teabe talletamise eest (toetab 4 andmebaasi: mysql, mssql, sqlite ja postgresql);
• artifact store — vastutab artefaktide salvestamise eest (toetab 7 salvestusvõimalust: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP-server, SFTP-server, NFS, HDFS).

Kuna artifact store lihtsuse huvides võtame sftp serveri.

• loome grupi

  $ sudo groupadd sftpg

• lisame kasutaja ja seadistame talle parooli

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• korrapäraselt muudame paar juurdepääsu seadistust

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

• lisame mõned read /etc/ssh/sshd_config

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

• taaskäivitame teenuse

  $ sudo systemctl restart sshd

Kuna backend pood võtame 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
# Loo uus kasutaja: mlflow_user
[postgres@user_name~]$ createuser --interactive -P
Sisestage lisatava rolli nimi: mlflow_user
Sisestage uue rolli parool: mlflow
Sisestage see uuesti: mlflow
Kas uuel rollil on superkasutaja õigused? (y/n) n
Kas uuel rollil on lubatud andmebaase luua? (y/n) n
Kas uuel rollil on lubatud luua uusi rolle? (y/n) n
# Looge andmebaas mlflow_bd, mille omanik on mlflow_user
$ createdb -O mlflow_user mlflow_db

Serveri käivitamiseks on vaja installida järgmised python paketid (soovitan luua eraldi virtuaalne keskkond):

pip install mlflow
pip install pysftp

Käivitame meie 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. Lisame jälgimise

Kuna meie treeningute tulemused ei kaoks, et tulevased arendajate põlvkonnad mõistaksid, mis tegelikult toimus, ja vanemad kolleegid ning teie saaksite rahus analüüsida õppeprotsessi, on meil vaja lisada jälgimine. Jälgimise all mõistetakse parameetrite, mõõdikute, artefaktide ja iga muu lisainformatsiooni salvestamist õppe käivitamise kohta, meie puhul serveris.

Näiteks olen ma loonud väikese projekti githubis Kerasel, et segmenteerida kõike, mis on COCO andmestikus. Jälgimise lisamiseks olen ma loonud faili mlflow_training.py.

Siin on read, kus toimub kõige huvitavam:

def run(self, epochs, lr, experiment_name):
        # saame eksperimendi id, luues eksperimendi, kui seda pole
        remote_experiment_id = self.remote_server.get_experiment_id(name=experiment_name)
        # loome "run" ja saame tema id
        remote_run_id = self.remote_server.get_run_id(remote_experiment_id)

        # näitame, et tahame tulemusi salvestada kaugserverisse
        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 väike mähis metodite üle mlflow.tracking. MlflowClient (tegin mugavuse huvides), mille abil loon katse ja käivitamise serveris. Edasi määran, kuhu tulemused peaksid suunama (mlflow.set_tracking_uri(self.tracking_uri)). Ühendame automaatse logimise mlflow.keras.autolog(). Praegu toetab MLflow Tracking automaatset logimist TensorFlow, Keras, Gluon XGBoost, LightGBM ja Spark raamistike jaoks. Kui te ei leidnud oma raamistike või teekide seast, siis võite alati logida kaudsetena. Käivitame koolituse. Registreerime sildid ja sisendparameetrid eemalserveris.

Mõne rea ja te olete, nagu kõik teisedki, saanud ligipääsu kogu käivituste teabele. Lahe, eks?

3. Kujunda projekt

Nüüd muudame nii, et projekti käivitamine oleks võimalikult lihtne. Selleks lisame projekti juurese MLproject faili ja conda.yaml.
MLproject

name: flow_segmentation
conda_env: conda.yaml

entry_points:
  main:
    parameters:
        categories: {help: 'coco andmebaasi kategooriate nimekiri'}
        epochs: {type: int, help: 'koolituse epohhide arv'}

        lr: {type: float, default: 0.001, help: 'õppimismäär'}
        batch_size: {type: int, default: 8}
        model_name: {type: str, default: 'Unet', help: 'Unet, PSPNet, Linknet, FPN'}
        backbone_name: {type: str, default: 'resnet18', help: 'näiteks resnet18, resnet50, mobilenetv2 ...'}

        tracking_uri: {type: str, help: 'serveri aadress'}
        experiment_name: {type: str, default: 'My_experiment', help: 'kaug- ja kohalik katse nimi'}
    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 Projectil on mitu omadust:

• Name — teie projekti nimi;
• Environment — minu puhul osutab conda_env sellele, et käivitamiseks kasutatakse Anacondat ja sõltuvuste kirjeldus asub failis conda.yaml;
• Entry Points — näitab, millis(e) fail(i) ja milliste parameetritega saame käivitada (kõik koolituse käivitamise parameetrid logitakse automaatselt)

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

Käivituskeskkonnana võite kasutada dockerit, lisateabe saamiseks pöörduge dokumentatsioonis.

4. Alustame koolitamist

Kloonime projekti ja liigutame projektikausta:

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

Ühenduse loomiseks peate installima raamatukogud

pip install mlflow
pip install pysftp

Kuna ma kasutan näites conda_env, peab teie arvutis olema installitud Anaconda (kuid seda saab mööda hiilida, installides kõik vajalikud paketid käsitsi ja mängides käivitamisparameetritega).

Kõik ettevalmistavad sammud on lõppenud ja saame alustada koolitamise käivitamist. Projekti juurest:

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

Käskude sisestamise järel luuakse automaatselt conda keskkond ja koolitus algab.
Ülaltoodud näites edastasin koolituse epohhide arvu, kategooriad, milleks tahame segmenteerida (täieliku nimekirja saab vaadata siit) ja meie kaugserveri aadress.
Kogu võimalike parameetrite loendi leiate failist MLproject.

5. Hindame koolituse tulemusi

Koolituse lõppedes saame brauseris minna meie serveri aadressile http://server_host:server_port

Siin näeme kõigi katsetuste nimekirja (vasakul ülal), samuti teavet käivituste kohta (keskel). Saame vaadata põhjalikumat teavet (parameetrid, mõõdikud, artefaktid ja mõningane lisainfo) iga käivituse kohta.

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

See tähendab, et praegu saame tulemusi analüüsida 'käsitsi' režiimis, samuti saate seadistada automaatset valideerimist MLflow API abil.

6. Registreerime mudeli

Pärast seda, kui oleme oma mudelit analüüsinud ja otsustanud, et see on lahinguks valmis, alustame selle registreerimist, valides vajaliku käivituse (nagu on näidatud eelmises punktis) ja liigume alla.

Pärast oma mudeli nime määramist on sellel nüüd versioon. Kui salvestada teine mudel sama nimega, tõuseb versioon automaatselt.

Iga mudeli jaoks saame lisada kirjelduse ja valida ühe kolmest olekust (Staging, Production, Archived). Hiljem saame nende olekudega API kaudu töötada, mis koos versioonihaldusega pakub lisafleksibiilsust.

Meil on mugav juurdepääs kõigile mudelitele

ja nende versioonidele

Nagu eelnevas punktis, saab kõik toimingud teostada API abil.

7. Deployed model

Selles etapis on meil juba treenitud (keras) mudel. Näide, kuidas seda kasutada:

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 taas väike ümberpakkimine üle mlflow.tracking.MlflowClient, et see oleks mugavam. Idee on selles, et ma pöördun kaugserveri poole ja otsin sealt mudelit, mille nimi on antud, nimelt viimast tootmisversiooni. Seejärel laadin artefaktu kohalikult kausta ./model ja kogun mudeli sellest kaustast mlflow.keras.load_model(local_path). Nüüd saame kasutada meie mudelit. CV (ML) arendajad saavad rahulikult tegeleda mudeli täiustamisega ja avaldada uusi versioone.

Kokkuvõtteks

Olen välja töötanud süsteemi, mis võimaldab:

• tsentraliseeritult hoida teavet ML mudelite, koolituse edenemise ja tulemuste kohta;
• kiirelt arendada arenduskeskkonda;
• jälgida ja analüüsida mudelite töö edenemist;
• mugavalt teha versioonihaldust ja hallata mudelite seisundeid;
• lihtsalt juurutada saadud mudeleid.

See näide on mänguline ja teenib lähtepunktina teie enda süsteemi ülesehitamiseks, mis võib hõlmata automaatset tulemuste hindamist ja mudelite registreerimist (vt 5 ja 6) või te lisate andmestike versioonimise või veel midagi muud? Ma püüdsin edastada mõtte, et teil on vaja MLOpsi tervikuna, MLflow on vaid vahend eesmärgi saavutamiseks.

Milliseid probleeme, millega te silmitsi seisate, ma ei käsitlenud?
Mida lisaksite süsteemi, et see kataks teie vajadused?
Milliseid tööriistu ja lähenemisviise kasutate, et lahendada kõik või osa probleemidest?

P.S. Jätan paar 링크:
Github projekt — https://github.com/simbakot/mlflow_example
MLflow — https://mlflow.org/
Minu töö e-post, küsimuste jaoks — ikryakin@croc.ru

Meie firmas toimub perioodiliselt erinevaid üritusi IT-specialistidele, näiteks: 8. juulil kell 19:00 MSK toimub online CV-üritus, kui huvi on, võite osaleda, registreerimine siit .

Allikas: habr.com