🥇MLOps - kuharska knjiga, 1. poglavje

Pozdravljeni vsi skupaj! Sem CV razvijalec v CROC-u. Projekte na področju življenjepisa izvajamo že 3 leta. V tem času smo naredili marsikaj, na primer: spremljali smo voznike, da med vožnjo ne pijejo, ne kadijo, ne telefonirajo, gledajo na cesto in ne v sanje ali v oblake. ; Posneli smo ljudi, ki vozijo po za to namenjenih pasovih in zavzamejo več parkirnih mest; zagotovil, da so delavci nosili čelade, rokavice itd.; identificiral zaposlenega, ki želi vstopiti v objekt; Prešteli smo vse, kar smo lahko.

Zakaj vse to počnem?

V procesu izvajanja projektov smo naleteli na zagate, veliko zapletov, nekatere probleme poznate ali jih boste spoznali v prihodnosti.

Simulirajmo situacijo

Predstavljajmo si, da smo se zaposlili v mladem podjetju "N", katerega dejavnosti so povezane z ML. Delamo na ML (DL, CV) projektu, nato iz nekega razloga preidemo na drugo službo, praviloma vzamemo odmor in se vrnemo k svojemu ali tujemu nevronu.

Pride trenutek resnice, nekako se morate spomniti, kje ste se ustavili, katere hiperparametre ste poskusili in, kar je najpomembneje, do kakšnih rezultatov so pripeljali. Obstaja veliko možnosti za to, kdo je shranil informacije o vseh zagonih: v glavi, konfiguracijah, beležnici, v delovnem okolju v oblaku. Slučajno sem videl možnost, ko so bili hiperparametri shranjeni kot komentirane vrstice v kodi, na splošno, polet domišljije. Zdaj pa si predstavljajte, da se niste vrnili k svojemu projektu, ampak k projektu osebe, ki je zapustila podjetje in ste podedovali kodo in model z imenom model_1.pb. Da dopolnimo sliko in prenesemo vso bolečino, si predstavljajmo, da ste tudi specialist začetnik.
Kar daj. Za izvajanje kode moramo mi in vsi, ki bomo delali z njo, ustvariti okolje. Pogosto se zgodi, da nam ga iz nekega razloga niso pustili v dediščino. To lahko postane tudi netrivialna naloga. Ne želite izgubljati časa s tem korakom, kajne?
Usposobimo model (npr. detektor avtomobila). Pridemo do točke, ko postane zelo dobro - čas je, da shranimo rezultat. Imenujmo ga car_detection_v1.pb. Nato usposobimo še enega - car_detection_v2.pb. Čez nekaj časa naši sodelavci ali mi sami poučujemo vedno več, z uporabo različnih arhitektur. Posledično nastane kup artefaktov, o katerih je treba skrbno zbirati informacije (vendar bomo to storili kasneje, ker imamo zaenkrat bolj prioritetne zadeve).
V redu, zdaj je vsega konec! Imamo model! Ali lahko začnemo usposabljati naslednji model, razvijati arhitekturo za rešitev novega problema, ali gremo lahko na čaj? In kdo bo razporedil?

Prepoznavanje težav

Delo na projektu ali izdelku je delo mnogih ljudi. In sčasoma ljudje odhajajo in prihajajo, projektov je več, sami projekti pa postanejo kompleksnejši. Tako ali drugače se bodo situacije iz zgoraj opisanega cikla (in ne le) v določenih kombinacijah pojavljale iz ponovitve v ponovitev. Posledica vsega tega je izgubljen čas, zmeda, živci, po možnosti nezadovoljstvo strank in na koncu izgubljen denar. Čeprav se navadno vsi ravnamo po istih starih grabljah, verjamem, da si nihče ne želi vedno znova podoživljati teh trenutkov.

Torej, šli smo skozi en razvojni cikel in vidimo, da obstajajo problemi, ki jih je treba rešiti. Za to potrebujete:

priročno shranjevanje rezultatov dela;
poenostaviti proces vključevanja novih sodelavcev;
poenostavite postopek uvajanja razvojnega okolja;
konfigurirajte postopek oblikovanja različic modela;
imeti priročen način za potrjevanje modelov;
najti vzorčno orodje za upravljanje stanja;
najti način za dostavo modelov v proizvodnjo.

Očitno je treba oblikovati potek dela, ki bi vam omogočil preprosto in priročno upravljanje tega življenjskega cikla? Ta praksa se imenuje MLOps

MLOps ali DevOps za strojno učenje omogoča ekipam podatkovne znanosti in IT, da sodelujejo in pospešijo razvoj in uvajanje modelov s spremljanjem, potrjevanjem in upravljanjem za modele strojnega učenja.

Lahko bratiKaj o vsem tem mislijo Googlovi fantje? Iz članka je razvidno, da je MLOps precej obsežna stvar.

V nadaljevanju bom v svojem članku opisal le del postopka. Za izvedbo bom uporabil orodje MLflow, saj... To je odprtokodni projekt, za povezavo je potrebna majhna količina kode in obstaja integracija s priljubljenimi ogrodji ml. V internetu lahko poiščete druga orodja, kot so Kubeflow, SageMaker, Trains itd., in morda najdete tisto, ki bolj ustreza vašim potrebam.

“Gradnja” MLOps na primeru uporabe orodja MLFlow

MLFlow je odprtokodna platforma za upravljanje življenjskega cikla ml modelov (https://mlflow.org/).

MLflow vključuje štiri komponente:

MLflow Tracking - pokriva vprašanja beleženja rezultatov in parametrov, ki so privedli do tega rezultata;
Projekt MLflow - omogoča pakiranje kode in njeno reprodukcijo na kateri koli platformi;
MLflow Models - odgovoren za uvajanje modelov v proizvodnjo;
Register MLflow – omogoča shranjevanje modelov in upravljanje njihovega stanja v centraliziranem repozitoriju.

MLflow deluje na dveh entitetah:

lansiranje je celoten cikel usposabljanja, parametrov in metrik, po katerih se želimo registrirati;
Poskus je »tema«, ki teče skupaj.

Vsi koraki primera so implementirani v operacijskem sistemu Ubuntu 18.04.

1. Razmestite strežnik

Da bomo lažje vodili naš projekt in prejemali vse potrebne informacije, bomo postavili strežnik. Strežnik za sledenje MLflow ima dve glavni komponenti:

backend store - odgovoren za shranjevanje informacij o registriranih modelih (podpira 4 DBMS: mysql, mssql, sqlite in postgresql);
artifact store - odgovoren za shranjevanje artefaktov (podpira 7 možnosti shranjevanja: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP server, SFTP Server, NFS, HDFS).

Kot trgovina z artefakti Za poenostavitev vzemimo strežnik sftp.

ustvarite skupino
```
$ sudo groupadd sftpg
```

dodajte uporabnika in mu nastavite geslo

$ sudo useradd -g sftpg mlflowsftp
$ sudo passwd mlflowsftp

prilagodite nekaj nastavitev dostopa

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

dodajte nekaj vrstic v /etc/ssh/sshd_config

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

znova zaženite storitev
```
$ sudo systemctl restart sshd
```

Kot zaledna trgovina Vzemimo 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

Za zagon strežnika morate namestiti naslednje pakete python (priporočam, da ustvarite ločeno virtualno okolje):

pip install mlflow
pip install pysftp

Zaženimo naš strežnik

$ 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. Dodajte sledenje

Da se rezultati našega usposabljanja ne bi izgubili, da bodo prihodnje generacije razvijalcev razumele, kaj se dogaja, in da bi starejši tovariši in vi lahko mirno analizirali učni proces, moramo dodati sledenje. Sledenje pomeni shranjevanje parametrov, metrik, artefaktov in vseh dodatnih informacij o začetku treninga, v našem primeru na strežnik.

Na primer, ustvaril sem majhno projekt na githubu na Kerasu za segmentiranje vsega, kar je v Nabor podatkov COCO. Za dodajanje sledenja sem ustvaril datoteko mlflow_training.py.

Tukaj so vrstice, kjer se dogajajo najbolj zanimive stvari:

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)

Tu je self.remote_server majhen ovoj nad metodami mlflow.tracking. MlflowClient (naredil sem zaradi priročnosti), s pomočjo katerega ustvarim eksperiment in ga poženem na strežniku. Nato navedem, kam naj se združijo rezultati zagona (mlflow.set_tracking_uri(self.tracking_uri)). Omogočim samodejno beleženje mlflow.keras.autolog(). Trenutno MLflow Tracking podpira samodejno beleženje za TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Če niste našli svojega ogrodja ali knjižnice, se lahko vedno izrecno prijavite. Začenjamo s treningi. Registrirajte oznake in vhodne parametre na oddaljenem strežniku.

Nekaj vrstic in tako kot vsi drugi imate dostop do informacij o vseh lansiranjih. kul?

3. Izdelamo projekt

Zdaj pa poenostavimo zagon projekta. Če želite to narediti, dodajte datoteki MLproject in conda.yaml v koren projekta.
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}"

Projekt MLflow ima več lastnosti:

Ime - ime vašega projekta;
Okolje – v mojem primeru conda_env označuje, da se za zagon uporablja Anaconda, opis odvisnosti pa je v datoteki conda.yaml;
Vstopne točke - označuje, katere datoteke in s katerimi parametri lahko izvajamo (vsi parametri se samodejno beležijo ob začetku treninga)

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 lahko uporabite kot svoje izvajalno okolje, za več podrobnosti glejte dokumentacijo.

4. Začnimo s treningom

Projekt kloniramo in gremo v imenik projektov:

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

Za zagon morate namestiti knjižnice

pip install mlflow
pip install pysftp

Ker v primeru, ki ga uporabljam conda_env, mora biti Anaconda nameščena na vašem računalniku (vendar se lahko temu izognete tako, da sami namestite vse potrebne pakete in se igrate s parametri zagona).

Vsi pripravljalni koraki so zaključeni in lahko začnemo z izvajanjem usposabljanja. Iz korena projekta:

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

Po vnosu ukaza se samodejno ustvari conda okolje in začne se usposabljanje.
V zgornjem primeru sem podal število epoh za usposabljanje, kategorije, v katere želimo segmentirati (ogledate si lahko celoten seznam tukaj) in naslov našega oddaljenega strežnika.
Celoten seznam možnih parametrov je na voljo v datoteki MLproject.

5. Ocenite učne rezultate

Po končanem izobraževanju lahko gremo v brskalniku na naslov našega strežnika http://server_host:server_port

Tukaj vidimo seznam vseh eksperimentov (zgoraj levo), kot tudi informacije o poskusih (na sredini). Ogledamo si lahko podrobnejše informacije (parametre, metrike, artefakte in nekatere dodatne informacije) za vsak zagon.

Za vsako metriko lahko opazujemo zgodovino sprememb

Tisti. Trenutno lahko analiziramo rezultate v “ročnem” načinu, prav tako pa lahko nastavite samodejno validacijo z MLflow API.

6. Registrirajte model

Ko smo analizirali naš model in se odločili, da je pripravljen za boj, ga nadaljujemo z registracijo, za to izberemo izstrelitev, ki jo potrebujemo (kot je prikazano v prejšnjem odstavku) in gremo dol.

Ko našemu modelu damo ime, ima različico. Če shranite drug model z istim imenom, bo različica samodejno nadgrajena.

Vsakemu modelu lahko dodamo opis in izberemo eno od treh stanj (Staging, Production, Archived), nato pa z API-jem dostopamo do teh stanj, kar skupaj z verzioniranjem zagotavlja dodatno fleksibilnost.

Do vseh modelov imamo tudi enostaven dostop

in njihove različice

Kot v prejšnjem odstavku lahko vse operacije izvedete z uporabo API-ja.

7. Namestite model

V tej fazi že imamo izurjen (keras) model. Primer, kako ga lahko uporabite:

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 je self.registry spet majhen ovoj nad mlflow.tracking.MlflowClient, zaradi priročnosti. Gre za to, da dostopam do oddaljenega strežnika in tam iščem model z navedenim imenom in zadnjo produkcijsko različico. Nato prenesem artefakt lokalno v mapo ./model in zgradim model iz tega imenika mlflow.keras.load_model(local_path). Zdaj lahko uporabimo naš model. CV (ML) razvijalci lahko preprosto izboljšajo model in objavijo nove različice.

Na koncu

Predstavil sem sistem, ki omogoča:

centralno shranjevanje informacij o modelih ML, napredku in rezultatih usposabljanja;
hitro namestite razvojno okolje;
spremljati in analizirati potek dela na modelih;
priročno je različicati in upravljati stanje modelov;
Nastale modele je enostavno namestiti.

Ta primer je igrača in služi kot izhodišče za gradnjo lastnega sistema, ki lahko vključuje avtomatizacijo vrednotenja rezultatov in registracijo modelov (točki 5 oziroma 6) ali pa boste dodali različico naborov podatkov ali morda kaj drugega? Bistvo, ki sem ga hotel povedati, je, da potrebujete MLOps kot celoto, MLflow pa je le sredstvo za dosego cilja.

Napišite, na katere težave ste naleteli in jih nisem prikazal?
Kaj bi dodali sistemu, da bo ustrezal vašim potrebam?
Katera orodja in pristope uporabljate za reševanje vseh ali dela težav?

PS Pustil bom par povezav:
projekt github - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Moj službeni e-poštni naslov za vprašanja - [e-pošta zaščitena]

Naše podjetje občasno gosti različne dogodke za IT strokovnjake, na primer: 8. julija ob 19:00 po moskovskem času bo CV srečanje v spletni obliki, če vas zanima, se lahko udeležite, registracija tukaj .

Vir: www.habr.com

MLOps - Kuharska knjiga, 1. poglavje