MLOps — Recepte, 1. nodaļa

Sveiki visiem! Es esmu CV izstrādātājs uzņēmumā KROK. Jau trīs gadus mēs īstenojam projektus CV jomā. Šajā laikā mēs esam paveikuši daudz, piemēram: uzraudzījām autovadītājus, lai ceļojuma laikā viņi nedzertu, nesmēķētu, nerunātu pa telefonu, skatītos uz ceļu, nevis sapņos vai mākoņos; reģistrējām tos, kuri mīl braukt pa atsevišķām joslām un ieņemt vairākas stāvvietas; kontrolējām, lai darbinieki valkātu ķiveres, cimdus utt.; identificējām darbinieku, kurš vēlas iekļūt objektā; saskaitījām visu, ko vien varēja.

Kāpēc es par to runāju?

Projektu realizācijas procesā mēs esam saskārušies ar grūtībām, daudzām grūtībām, ar daļu no problēmām jūs varat būt pazīstami vai arī iepazīsieties nākotnē.

Modelēsim situāciju

Iedomāsimies, ka mēs esam sākuši strādāt jaunā uzņēmumā “N”, kura darbība saistīta ar ML. Mēs strādājam pie ML (DL, CV) projekta, pēc tam kādu iemeslu dēļ mēs pārslēdzam uzmanību uz citu darbu, kopumā veicam pārtraukumu un atgriežamies pie savas vai citas neironu sistēmas.

1. Nāk brīdis patiesībai, ir jāatceras, pie kā tu esi apstājies, kādus hiperparametrus esi izmēģinājis un, pats galvenais, kādi rezultāti tie ir devuši. Var būt daudz variantu, kā cilvēki ir glabājuši informāciju par visiem palaišanas darbiem: galvā, konfigurācijās, piezīmju grāmatiņā, darba vidē mākoņos. Man ir bijusi iespēja redzēt variantu, kad hiperparametri tika glabāti kā komentētas rindas kodā, vispār - radošuma lidojums. Un tagad iedomājieties, ka jūs atgriezāties nevis pie sava projekta, bet pie cilvēka projekta, kurš pameta uzņēmumu, un jums mantojuma veidā palika kods un modelis ar nosaukumu model_1.pb. Lai pilnībā izprastu situāciju un nodotu visas ciešanas, iedomāsimies, ka esat arī sākuma līmeņa speciālists.
2. Turpināsim. Lai palaistu kodu, mums un visiem, kas ar to strādās, ir nepieciešams izveidot vidi. Bieži vien izrādās, ka šī vide mums arī par kādiem iemesliem nav atstāta. Tas arī var būt ne vienkāršs uzdevums. Šim solim negribas tērēt laiku, vai ne?
3. Mēs apmācām modeli (piemēram, automašīnu detektoru). Nonākam līdz brīdim, kad tas ir diezgan labs — ir īstais laiks saglabāt rezultātu. Nosauksim to par car_detection_v1.pb. Pēc tam apmācām vēl vienu — car_detection_v2.pb. Pēc kādā laika mūsu kolēģi vai mēs paši apmācam vēl un vēl, izmantojot dažādas arhitektūras. Galu galā veidojas kaudze artefaktu, kuru informāciju jākrāj (bet to darīsim vēlāk, jo mums ir prioritārāki darbi).
4. Nu, lūk, viss ir gatavs! Mums ir modelis! Mēs varam sākt nākamā modeļa apmācību, izstrādāt arhitektūru jaunai uzdevuma risināšanai vai varbūt doties dzert tēju? Bet kurš veiks izvietošanu?

Identificējam problēmas

Darbs pie projekta vai produkta ir daudzu cilvēku darbs. Laika gaitā cilvēki nāk un iet, projektu paliek arvien vairāk, paši projekti kļūst sarežģītāki. Tā vai citādi situācijas no iepriekš minētā cikla (un ne tikai) dažādās kombinācijās atkārtosies katrā iterācijā. Viss tas noved pie laika zuduma, neskaidrībām, nervu spriedzes, iespējams — klienta neapmierinātības un, galu galā — pie zaudētiem ienākumiem. Lai arī mēs parasti staigājam pa vecām grābļiem, tomēr neviens nevēlas atkal un atkal pārdzīvot šos brīžus.

Tātad, mēs esam izgājuši cauri vienam izstrādes ciklam un redzam, ka ir problēmas, kuras jārisina. Lai to izdarītu, ir nepieciešams:

• ērti glabāt darba rezultātus;
• padarīt darbinieku iesaisti vieglu;
• vienkāršot izstrādes vides izvietošanas procesu;
• iestatīt modeļu versiju pārvaldības procesu;
• iegūt ērtu veidu modeļu validēšanai;
• atrast instrumentu modeļu stāvokļa pārvaldībai;
• atrast veidu, kā piegādāt modeļus ražošanā.

Acīmredzot ir jāizdomā darba plūsma, kas ļautu viegli un ērti pārvaldīt šo dzīves ciklu? Šai praksei ir nosaukums MLOps.

MLOps, vai DevOps mašīnmācībai, ļauj datu apstrādes un analīzes speciālistu un IT speciālistu komandām sadarboties, kā arī paātrināt modeļu izstrādes un izvietošanas tempu, izmantojot uzraudzības, pārbaudes un vadības sistēmu mašīnmācības modeļiem.

Jūs varat izlasīt, ko par to domā puiši no Google. No raksta skaidrs, ka MLOps ir diezgan plaša tēma.

Tālāk savā rakstā aprakstīšu tikai daļu no procesa. Realizācijai es izmantošu rīku MLflow, jo tas ir open-source projekts, tāpēc, lai to pieslēgtu, nepieciešams neliels kods un ir integrācija ar populāriem ML ietvariem. Jūs varat meklēt citus rīkus internetā, piemēram, Kubeflow, SageMaker, Trains utt., un, iespējams, atrast to, kas vislabāk atbilst jūsu vajadzībām.

"Veidojam" MLOps piemēra izmantošanā rīka MLFlow.

MLFlow — tas ir atvērtā koda platforma mašīnmācīšanās modeļu dzīves cikla pārvaldībai (https://mlflow.org/).

MLflow ietver četrus komponentus:

• MLflow Tracking — risina jautājumus par rezultātu un parametru fiksēšanu, kas noveda pie šiem rezultātiem;
• MLflow Project — ļauj iepakot kodu un atkārtoti to izmantot jebkurā platformā;
• MLflow Models — atbild par modeļu izvietošanu ražošanā;
• MLflow Registry — ļauj glabāt modeļus un pārvaldīt to stāvokli centralizētā krātuvē.

MLflow strādā ar divām entītēm:

• skrējiens — tas ir pilns mācību cikls, parametri un metrikas, kuras mēs vēlamies reģistrēt;
• eksperiments — tā ir “tematika”, kas apvieno skrējienus.

Visi piemēra soļi ir īstenoti operētājsistēmā Ubuntu 18.04.

1. Uzliekam serveri.

Lai mēs varētu viegli pārvaldīt mūsu projektu un saņemt visu nepieciešamo informāciju, uzliksim serveri. MLflow tracking serverim ir divi galvenie komponenti:

• backend store — atbild par reģistrēto modeļu informācijas glabāšanu (atbalsta 4 DBMS: mysql, mssql, sqlite un postgresql);
• artifact store — atbild par ar teiktajiem artefaktiem (atbalsta 7 glabāšanas varianti: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP serveris, SFTP serveris, NFS, HDFS).

Kā artifact store vienkāršības labad ņemsim sftp serveri.

• izveidojam grupu

  $ sudo groupadd sftpg

• pievienojam lietotāju un uzstādām viņam paroli

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• pielāgojam 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

• pievienojam dažas rindas failā /etc/ssh/sshd_config

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

• pārstartējam pakalpojumu

  $ sudo systemctl restart sshd

Kā backend store ņemam 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
# Izveido jaunu lietotāju: mlflow_user
[postgres@user_name~]$ createuser --interactive -P
Ievadiet lomu nosaukumu, ko pievienot: mlflow_user
Ievadiet paroli jaunajai lomai: mlflow
Ievadiet to vēlreiz: mlflow
Vai jaunajai lomai jābūt superlietotājam? (y/n) n
Vai jaunajai lomai jāļauj izveidot datu bāzes? (y/n) n
Vai jaunajai lomai jāļauj izveidot nākamās jaunās lomas? (y/n) n
# Izveidojam datu bāzi mlflow_bd, kas pieder mlflow_user
$ createdb -O mlflow_user mlflow_db

Lai uzsāktu serveri, nepieciešams instalēt šādus Python paketus (iesaku izveidot atsevišķu virtuālo vidi):

pip install mlflow
pip install pysftp

Uzsākam 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. Pievienojam sekošanu

Lai nodrošinātu, ka mūsu apmācību rezultāti netiek zaudēti, nākamajām izstrādātāju paaudzēm saprastu, kas vispār notika, un vecākie kolēģi un jūs varētu mierīgi analizēt mācību procesu, mums ir nepieciešams pievienot sekošanu. Sekošana nozīmē parametru, metrikas, artefaktu un jebkādas papildu informācijas par mācību uzsākšanu saglabāšanu, mūsu gadījumā, serverī.

Piemēram, es izveidoju nelielu projektu github uz Keras visam, kas ir pieejams COCO datu kopā. Lai pievienotu sekošanu, es izveidoju failu mlflow_training.py.

Šeit ir rindiņas, kurās notiek viss interesantais:

def run(self, epochs, lr, experiment_name):
        # iegūstam eksperimenta id, izveidojam eksperimentu tā neesamības gadījumā
        remote_experiment_id = self.remote_server.get_experiment_id(name=experiment_name)
        # izveidojam "run" un iegūstam tā id
        remote_run_id = self.remote_server.get_run_id(remote_experiment_id)

        # norādām, ka vēlamies rezultātus saglabāt attālinātajā 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 neliela saite uz mlflow.tracking metodes MlflowClient (es to izveidoju ērtībai), ar kurām es izveidoju eksperimentu un palaišanu serverī. Tālāk es norādu, kur jāiesniedz palaišanas rezultāti (mlflow.set_tracking_uri(self.tracking_uri)). Pievienoju automātisko mlflow.keras.autologēšanu. Šobrīd MLflow Tracking atbalsta automātisko logu veidošanu šādiem rīkiem: TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Ja jūs neatradāt savu ietvaru vai bibliotēku, jūs vienmēr varat logu reģistrēt manuāli. Sāksim apmācību. Reģistrējam tagus un ieejas parametrus attālinātajā serverī.

Dažas rindas, un jums, tāpat kā visiem interesentiem, ir piekļuve visai informācijai par visiem palaišanas procesiem. Ai, forši?

3. Projekta izveide

Tagad padarīsim tā, lai projekta palaišana būtu vienkārša. Šim nolūkam pievienosim MLproject un conda.yaml failus projekts saknē.
MLproject

name: flow_segmentation
conda_env: conda.yaml

entry_points:
  main:
    parameters:
        categories: {help: 'kategoriju saraksts no coco datu kopas'}
        epochs: {type: int, help: 'apmācības epoch skaits'}

        lr: {type: float, default: 0.001, help: 'mācību ātrums'}
        batch_size: {type: int, default: 8}
        model_name: {type: str, default: 'Unet', help: 'Unet, PSPNet, Linknet, FPN'}
        backbone_name: {type: str, default: 'resnet18', help: 'piemērs: resnet18, resnet50, mobilenetv2 ...'}

        tracking_uri: {type: str, help: 'servera adrese'}
        experiment_name: {type: str, default: 'My_experiment', help: 'attālinātā un vietējā eksperimenta nosaukums'}
    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 projekts ir ar vairākām īpašībām:

• Name — jūsu projekta nosaukums;
• Environment — manā gadījumā conda_env norāda, ka palaišanai tiek izmantota Anaconda, un atkarības apraksts atrodas conda.yaml failā;
• Entry Points — norādīts, kādus failus un ar kādiem parametriem mēs varam palaist (visi parametri apmācības laikā automātiski tiek logēti)

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ā izpildes vidi jūs varat izmantot docker, par sīkāku informāciju skatieties dokumentācijā.

4. Uzsākam apmācību

Klonējam projektu un pārejam uz projekta direktoriju:

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

Lai palaišanas process darbotos, jums ir jāsagatavo bibliotēkas

pip install mlflow
pip install pysftp

Tā kā piemērā es izmantoju conda_env, jūsu datorā ir jābūt uzstādītai Anaconda (taču to var apiet, pats uzstādot visus nepieciešamos pakotnes un nedaudz pielāgojot palaišanas parametrus).

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 izveidots conda vide un uzsāksies apmācība.
Iepriekšējā piemērā es norādīju apmācību epoch skaitu, kategorijas, uz kurām mēs vēlamies segmentēt (pilnu sarakstu var skatīt šeit) un mūsu attālinātā servera adresi.
Pilnu iespējamo parametru sarakstu var apskatīt MLproject failā.

5. Novērtējam apmācības rezultātus

Pēc apmācības beigām mēs varam pāriet pārlūkā uz mūsu servera adresi http://server_host:server_port

Šeit mēs redzam visu eksperimentu sarakstu (pa kreisi augšējā stūrī), kā arī informāciju par palaišanām (vidū). Mēs varam skatīt detalizētāku informāciju (parametri, metriķi, artefakti un kāda papildu informācija) par katru palaišanu.

Par katru metriķi mēs varam novērot mainīgo vēsturi.

Tātad šobrīd mēs varam analizēt rezultātus "roku" režīmā, arī jūs varat konfigurēt automātisko validāciju, izmantojot MLflow API.

6. Reģistrējam modeli

Pēc tam, kad mēs esam analizējuši mūsu modeli un nolēmuši, ka tas ir gatavs, mēs reģistrējam to, izvēloties nepieciešamo palaišanu (kā parādīts iepriekšējā punktā) un dodamies lejup.

Pēc tam, kad mēs esam devuši savai modelim nosaukumu, tas iegūst versiju. Saglabājot citu modeli ar to pašu nosaukumu, versija automātiski paaugstinās.

Katram modelim mēs varam pievienot aprakstu un izvēlēties vienu no trim stāvokļiem (Staging, Production, Archived), turpmāk mēs varam piekļūt šiem stāvokļiem, izmantojot API, kas kopā ar versiju pārvaldību nodrošina papildu elastību.

Mums arī ir ērta piekļuve visiem modeļiem

un to versijām.

Kā iepriekšējā punktā, visas darbības var veikt, izmantojot API.

7. Ieviešam 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 ir atkārtota vienkārša saskarne ar mlflow.tracking.MlflowClient, lai būtu ērtāk. Svarīgi ir tas, ka es piekļušu attālinātajam serverim un meklēšu tur modeli ar norādīto nosaukumu, proti, pēdējo produkcijas versiju. Pēc tam lejupielādēju artefaktu vietējā mapē .\/model un uztveru modeli no šīs direktorijas mlflow.keras.load_model(local_path). Tagad varam izmantot mūsu modeli. CV (ML) izstrādātāji var mierīgi strādāt pie modeļa uzlabošanas un publicēt jaunas versijas.

Noslēgumā

Es piedāvāju sistēmu, kas ļauj:

• centralizēti uzglabāt informāciju par ML modeļiem, to apmācības gaitu un rezultātiem;
• ātri izvērst izstrādes vidi;
• sekot līdzi un analizēt darbu pie modeļiem;
• ērti veidot versiju un pārvaldīt modeļu stāvokli;
• vieglāk izvietot iegūtos modeļus.

Šis piemērs ir izglītojošs un kalpo kā sākumpunkts jūsu pašu sistēmas izveidei, kas, iespējams, ietver automātisku rezultātu novērtēšanu un modeļu reģistrāciju (5. un 6. punkts attiecīgi), vai jūs pievienosiet datu kopu versiju veidošanu, vai varbūt vēl ko citu? Es gribēju sniegt priekšstatu, ka jums ir nepieciešams MLOps kopumā, MLflow ir vienkārši līdzeklis mērķu sasniegšanai.

Uzrakstiet, kādas problēmas jūs saskārāties, es tās neparādīju?
Ko jūs pievienotu sistēmai, lai tā apmierinātu jūsu vajadzības?
Kurus rīkus un pieejas jūs izmantojat, lai risinātu visas vai daļu problēmu?

P.S. Atstāšu dažas saites:
github projekts — https://github.com/simbakot/mlflow_example
MLflow — https://mlflow.org/
Mana darba e-pasta adrese, ja ir jautājumi — ikryakin@croc.ru

Mūsu uzņēmumā periodiski tiek rīkoti dažādi pasākumi IT speciālistiem, piemēram: 8. jūlijā plkst. 19:00 pēc MGS notiks tiešsaistes tikšanās par CV, ja interesē, varat piedalīties, reģistrācija šeit .

Avots: habr.com