MLOps — pavārgrāmata, 1. nodaļa

Sveiki visiem! Esmu CV izstrādātājs uzņēmumā CROC. Jau 3 gadus īstenojam projektus CV jomā. Šajā laikā mēs darījām daudzas lietas, piemēram: uzraudzījām autovadītājus, lai viņi braukšanas laikā nedzertu, nesmēķētu, nerunātu pa telefonu, neskatītos uz ceļu, nevis uz sapņiem vai mākoņiem. ; Mēs reģistrējām cilvēkus, kuri brauc pa tām paredzētajām joslām un aizņem vairākas stāvvietas; nodrošināja, ka strādnieki valkā ķiveres, cimdus utt.; identificēja darbinieku, kurš vēlas iekļūt objektā; Saskaitījām visu, ko varējām.

Priekš kam es to visu daru?

Īstenojot projektus, mēs saskaramies ar izciļņiem, daudz izciļņiem, dažām problēmām, ar kurām jūs vai nu esat pazīstami, vai arī iepazīsities nākotnē.

Simulēsim situāciju

Iedomāsimies, ka esam iekārtojušies darbā jaunā uzņēmumā “N”, kura darbība ir saistīta ar ML. Mēs strādājam pie ML (DL, CV) projekta, pēc tam kaut kādu iemeslu dēļ pārslēdzamies uz citu darbu, parasti paņemam pārtraukumu un atgriežamies pie sava vai kāda cita neirona.

1. Pienāk patiesības brīdis, kaut kā jāatceras, kur apstājies, kādus hiperparametrus mēģinājusi un, galvenais, pie kādiem rezultātiem tie noveda. Var būt daudz iespēju, kas glabāja informāciju par visiem palaišanas gadījumiem: galvā, konfigurācijās, piezīmju blokā, darba vidē mākonī. Man gadījās redzēt opciju, kad hiperparametri tika saglabāti kā komentētas rindiņas kodā, kopumā tas ir izdomājums. Tagad iedomājieties, ka atgriezāties nevis pie sava projekta, bet gan pie tādas personas projekta, kura pameta uzņēmumu, un jūs mantojāt kodu un modeli ar nosaukumu model_1.pb. Lai pabeigtu attēlu un nodotu visas sāpes, iedomāsimies, ka esat arī iesācējs speciālists.
2. Uz priekšu. Lai palaistu kodu, mums un visiem, kas ar to strādās, ir jāizveido vide. Bieži gadās, ka kādu iemeslu dēļ viņi nav atstājuši viņu kā mūsu mantojumu. Tas var kļūt arī par nenozīmīgu uzdevumu. Jūs nevēlaties tērēt laiku šim solim, vai ne?
3. Apmācam modeli (piemēram, auto detektoru). Mēs esam nonākuši līdz vietai, kur tas kļūst ļoti labs – ir pienācis laiks saglabāt rezultātu. Sauksim to par car_detection_v1.pb. Tad apmācām vēl vienu - car_detection_v2.pb. Pēc kāda laika mūsu kolēģi vai mēs paši mācām arvien vairāk, izmantojot dažādas arhitektūras. Rezultātā veidojas artefaktu gūzma, par kuriem informācija ir rūpīgi jāsavāc (bet mēs to darīsim vēlāk, jo šobrīd mums ir vairāk prioritāru lietu).
4. Labi, tagad viss ir beidzies! Mums ir modelis! Vai mēs varam sākt apmācīt nākamo modeli, izstrādāt arhitektūru, lai atrisinātu jaunu problēmu, vai arī mēs varam iedzert tēju? Un kurš izvietos?

Problēmu identificēšana

Darbs pie projekta vai produkta ir daudzu cilvēku darbs. Un ar laiku cilvēki aizbrauc un nāk, projektu ir vairāk, un paši projekti kļūst sarežģītāki. Tā vai citādi situācijas no iepriekš aprakstītā cikla (un ne tikai) noteiktās kombinācijās notiks no iterācijas uz iterāciju. Tas viss rada lieku laiku, apjukumu, nervus, iespējams, klientu neapmierinātību un galu galā naudas zaudēšanu. Lai gan mēs visi parasti sekojam vienam un tam pašam vecajam grābeklim, es uzskatu, ka neviens nevēlas šos mirkļus izdzīvot atkal un atkal.

Tātad esam izgājuši vienu attīstības ciklu un redzam, ka ir problēmas, kas jārisina. Lai to izdarītu, jums ir nepieciešams:

• ērti uzglabāt darba rezultātus;
• vienkāršot jaunu darbinieku iesaistīšanas procesu;
• vienkāršot izstrādes vides izvietošanas procesu;
• konfigurēt modeļa versiju veidošanas procesu;
• ir ērts modeļu apstiprināšanas veids;
• atrast paraugvalsts pārvaldības rīku;
• atrast veidu, kā modeļus piegādāt ražošanā.

Acīmredzot ir jāizdomā darbplūsma, kas ļautu viegli un ērti pārvaldīt šo dzīves ciklu? Šo praksi sauc par MLOps

MLOps jeb DevOps mašīnmācībai ļauj datu zinātnes un IT komandām sadarboties un palielināt modeļu izstrādes un izvietošanas tempu, izmantojot mašīnmācīšanās modeļu uzraudzību, validāciju un pārvaldību.

Jūs varat lasītKo par to visu domā Google puiši? No raksta ir skaidrs, ka MLOps ir diezgan apjomīga lieta.

Tālāk savā rakstā es aprakstīšu tikai daļu no procesa. Ieviešanai izmantošu MLflow rīku, jo... Šis ir atvērtā pirmkoda projekts, savienojuma izveidei ir nepieciešams neliels koda daudzums un ir integrācija ar populāriem ml ietvariem. Varat meklēt internetā citus rīkus, piemēram, Kubeflow, SageMaker, Trains utt., un, iespējams, atrast to, kas labāk atbilst jūsu vajadzībām.

MLOps “veidošana”, izmantojot MLFlow rīka izmantošanas piemēru

MLFlow ir atvērtā koda platforma ml modeļu dzīves cikla pārvaldībai (https://mlflow.org/).

MLflow ietver četrus komponentus:

• MLflow Tracking – aptver jautājumus par rezultātu ierakstīšanu un parametriem, kas noveda pie šī rezultāta;
• MLflow Project - ļauj iepakot kodu un reproducēt to uz jebkuras platformas;
• MLflow modeļi - atbild par modeļu izvietošanu ražošanā;
• MLflow reģistrs - ļauj uzglabāt modeļus un pārvaldīt to stāvokli centralizētā repozitorijā.

MLflow darbojas divās entītijās:

• palaišana ir pilns apmācības, parametru un metrikas cikls, pēc kura mēs vēlamies reģistrēties;
• Eksperiments ir “tēma”, kas darbojas kopā.

Visas piemēra darbības ir ieviestas operētājsistēmā Ubuntu 18.04.

1. Izvietojiet serveri

Lai mēs varētu ērti pārvaldīt savu projektu un saņemt visu nepieciešamo informāciju, mēs izvietosim serveri. MLflow izsekošanas serverim ir divas galvenās sastāvdaļas:

• backend veikals — atbild par reģistrēto modeļu informācijas glabāšanu (atbalsta 4 DBVS: mysql, mssql, sqlite un postgresql);
• artefaktu veikals - atbild par artefaktu glabāšanu (atbalsta 7 krātuves iespējas: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP serveris, SFTP serveris, NFS, HDFS).

Kā artefaktu veikals Vienkāršības labad ņemsim sftp serveri.

• izveidot grupu

  $ sudo groupadd sftpg

• pievienojiet lietotāju un iestatiet viņam paroli

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• pielāgojot pāris piekļuves iestatījumus

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

• pievienojiet dažas rindiņas /etc/ssh/sshd_config

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

• restartējiet pakalpojumu

  $ sudo systemctl restart sshd

Kā aizmugures veikals Ņemsim 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

Lai startētu serveri, jāinstalē šādas python pakotnes (iesaku izveidot atsevišķu virtuālo vidi):

pip install mlflow
pip install pysftp

Sāksim mūsu 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. Pievienojiet izsekošanu

Lai mūsu apmācības rezultāti nepazustu, nākamās izstrādātāju paaudzes saprastu, kas notiek, un vecāki biedri un jūs varētu mierīgi analizēt mācību procesu, mums ir jāpievieno izsekošana. Izsekošana nozīmē parametru, metrikas, artefaktu un jebkuras papildu informācijas par apmācības sākumu saglabāšanu serverī.

Piemēram, es izveidoju mazu projekts vietnē github uz Keras, lai segmentētu visu, kas ir iekšā COCO datu kopa. Lai pievienotu izsekošanu, es izveidoju failu mlflow_training.py.

Šeit ir rindas, kurās notiek visinteresantākās lietas:

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)

Šeit self.remote_server ir neliels mlflow.tracking metožu iesaiņojums. MlflowClient (izgatavoju ērtības labad), ar kura palīdzību izveidoju eksperimentu un palaistu to serverī. Tālāk es norādu, kur palaišanas rezultāti ir jāapvieno (mlflow.set_tracking_uri(self.tracking_uri)). Es iespējoju automātisko reģistrēšanu mlflow.keras.autolog(). Pašlaik MLflow Tracking atbalsta automātisku reģistrēšanu TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Ja neesat atradis savu sistēmu vai bibliotēku, vienmēr varat skaidri reģistrēties. Sākam treniņus. Reģistrējiet tagus un ievades parametrus attālajā serverī.

Pāris rindiņas, un jūs, tāpat kā visi pārējie, varēsit piekļūt informācijai par visiem palaišanas gadījumiem. Forši?

3. Izstrādājam projektu

Tagad atvieglosim projekta uzsākšanu. Lai to izdarītu, pievienojiet MLproject un conda.yaml failu projekta saknei.
MLprojekts

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 projektam ir vairākas īpašības:

• Name - jūsu projekta nosaukums;
• Vide — manā gadījumā conda_env norāda, ka palaišanai tiek izmantota Anaconda un atkarības apraksts ir failā conda.yaml;
• Entry Points - norāda, kurus failus un ar kādiem parametriem varam palaist (visi parametri tiek automātiski reģistrēti, uzsākot treniņu)

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

Varat izmantot docker kā savu izpildlaika vidi. Plašāku informāciju skatiet šeit dokumentācija.

4. Sāksim trenēties

Mēs klonējam projektu un dodamies uz projekta direktoriju:

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

Lai palaistu, ir jāinstalē bibliotēkas

pip install mlflow
pip install pysftp

Jo piemērā es izmantoju conda_env, Anaconda ir jāinstalē datorā (bet to var apiet, pats instalējot visas nepieciešamās pakotnes un spēlējoties ar palaišanas parametriem).

Visas sagatavošanās darbības ir pabeigtas, un mēs varam sākt apmācību. No projekta saknes:

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

Pēc komandas ievadīšanas automātiski tiks izveidota conda vide un sāksies apmācība.
Iepriekš minētajā piemērā es nokārtoju apmācības periodu skaitu, kategorijas, kurās mēs vēlamies segmentēt (jūs varat redzēt pilnu sarakstu šeit) un mūsu attālā servera adrese.
Pilns iespējamo parametru saraksts ir atrodams MLproject failā.

5. Novērtēt mācību rezultātus

Pēc apmācības pabeigšanas mēs varam pārlūkprogrammā doties uz mūsu servera adresi http://server_host:server_port

Šeit mēs redzam visu eksperimentu sarakstu (augšējā kreisajā pusē), kā arī informāciju par izpildēm (vidū). Mēs varam skatīt detalizētāku informāciju (parametrus, metriku, artefaktus un papildu informāciju) par katru palaišanu.

Katram rādītājam mēs varam novērot izmaiņu vēsturi

Tie. Šobrīd rezultātus varam analizēt “manuālā” režīmā, kā arī varat iestatīt automātisku validāciju, izmantojot MLflow API.

6. Reģistrējiet modeli

Pēc tam, kad esam analizējuši savu modeli un nolēmuši, ka tas ir gatavs kaujai, mēs turpinām to reģistrēt, šim nolūkam mēs atlasām vajadzīgo palaišanu (kā parādīts iepriekšējā punktā) un dodamies uz leju.

Pēc tam, kad esam piešķīruši modelim nosaukumu, tam ir versija. Ja saglabājat citu modeli ar tādu pašu nosaukumu, versija tiks automātiski jaunināta.

Katram modelim mēs varam pievienot aprakstu un atlasīt vienu no trim stāvokļiem (Iestudējums, Ražošana, Arhivēts); pēc tam, izmantojot API, mēs varam piekļūt šiem stāvokļiem, kas kopā ar versiju veidošanu nodrošina papildu elastību.

Mums ir arī viegla piekļuve visiem modeļiem

un to versijas

Tāpat kā iepriekšējā rindkopā, visas darbības var veikt, izmantojot API.

7. Izvietojiet modeli

Šajā posmā mums jau ir apmācīts (keras) modelis. Piemērs, kā to var izmantot:

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

Šeit self.registry atkal ir neliels iesaiņojums virs mlflow.tracking.MlflowClient ērtībai. Lieta tāda, ka es piekļūstu attālajam serverim un meklēju tur modeli ar norādīto nosaukumu un jaunāko ražošanas versiju. Pēc tam es lejupielādēju artefaktu lokāli mapē ./model un izveido modeli no šī direktorija mlflow.keras.load_model(local_path). Tagad mēs varam izmantot mūsu modeli. CV (ML) izstrādātāji var viegli uzlabot modeli un publicēt jaunas versijas.

Noslēgumā

Es prezentēju sistēmu, kas ļauj:

• centralizēti glabā informāciju par ML modeļiem, treniņu gaitu un rezultātiem;
• ātri izvietot izstrādes vidi;
• uzraudzīt un analizēt darba gaitu pie modeļiem;
• ir ērti versēt un pārvaldīt modeļu stāvokli;
• Iegūtos modeļus ir viegli izvietot.

Šis piemērs ir rotaļlieta un kalpo kā sākumpunkts savas sistēmas izveidei, kas var ietvert rezultātu novērtēšanas un modeļu reģistrēšanas automatizāciju (attiecīgi 5. un 6. punkts), vai arī pievienosiet datu kopu versijas, vai varbūt kaut ko citu? Es centos uzsvērt, ka jums ir nepieciešams MLOps kopumā, MLflow ir tikai līdzeklis mērķa sasniegšanai.

Uzrakstiet, ar kādām problēmām saskārāties, kuras es neparādīju?
Ko jūs pievienotu sistēmai, lai tā atbilstu jūsu vajadzībām?
Kādus rīkus un pieejas izmantojat, lai atrisinātu visas problēmas vai daļu no tām?

PS atstāšu pāris saites:
github projekts - https://github.com/simbakot/mlflow_example
MLflow — https://mlflow.org/
Mans darba e-pasts jautājumiem - [e-pasts aizsargāts]

Mūsu uzņēmumā periodiski notiek dažādi pasākumi IT speciālistiem, piemēram: 8. jūlijā 19:00 pēc Maskavas laika notiks CV tikšanās online formātā, ja ir interese, var piedalīties, reģistrācija šeit .

Avots: www.habr.com