🥇MLOps - Kogebog, kapitel 1

Hej alle! Jeg er CV-udvikler hos CROC. Vi har gennemført projekter inden for CV i 3 år nu. I løbet af denne tid gjorde vi mange ting, for eksempel: vi overvågede bilister, så de under kørslen ikke drak, røg ikke, talte ikke i telefon, kiggede på vejen og ikke på drømme eller på skyerne ; Vi optog folk, der kører i dedikerede baner og optager flere parkeringspladser; sikret, at arbejderne bar hjelme, handsker osv.; identificeret en medarbejder, der ønsker at komme ind på anlægget; Vi talte alt, hvad vi kunne.

Hvad laver jeg alt dette for?

I processen med at gennemføre projekter rammer vi bump, en masse bump, nogle af de problemer du enten kender til eller vil stifte bekendtskab med i fremtiden.

Lad os simulere situationen

Lad os forestille os, at vi fik et job i en ung virksomhed "N", hvis aktiviteter er relateret til ML. Vi arbejder på et ML (DL, CV) projekt, så skifter vi af en eller anden grund til et andet job, tager generelt en pause og vender tilbage til vores egen eller en andens neuron.

Sandhedens øjeblik kommer, du skal på en eller anden måde huske, hvor du stoppede, hvilke hyperparametre du prøvede og, vigtigst af alt, hvilke resultater de førte til. Der kan være mange muligheder for, hvem der har gemt information på alle lanceringer: i hovedet, konfigurationer, notesblok, i et arbejdsmiljø i skyen. Jeg så tilfældigvis en mulighed, når hyperparametre blev gemt som kommenterede linjer i koden, generelt en fantasi. Forestil dig nu, at du ikke vendte tilbage til dit projekt, men til projektet af en person, der forlod virksomheden, og du har arvet en kode og en model kaldet model_1.pb. For at fuldende billedet og formidle al smerten, lad os forestille os, at du også er en begynderspecialist.
Fortsæt. For at køre koden skal vi og alle, der vil arbejde med den, skabe et miljø. Det sker ofte, at de af en eller anden grund ikke efterlod ham som vores arv. Dette kan også blive en ikke-triviel opgave. Du ønsker ikke at spilde tid på dette trin, gør du?
Vi træner en model (for eksempel en bildetektor). Vi når til det punkt, hvor det bliver meget godt - det er tid til at gemme resultatet. Lad os kalde det car_detection_v1.pb. Så træner vi endnu en - car_detection_v2.pb. Nogen tid senere underviser vores kolleger eller vi selv mere og mere ved at bruge forskellige arkitekturer. Som et resultat dannes der en masse artefakter, hvorom information skal indsamles møjsommeligt (men vi vil gøre dette senere, for for nu har vi flere prioriterede sager).
OK, det hele er slut nu! Vi har en model! Kan vi begynde at træne den næste model, udvikle en arkitektur til at løse et nyt problem, eller kan vi tage en kop te? Og hvem vil indsætte?

Identifikation af problemer

At arbejde på et projekt eller produkt er mange menneskers arbejde. Og med tiden går folk og kommer, der er flere projekter, og selve projekterne bliver mere komplekse. På en eller anden måde vil situationer fra den ovenfor beskrevne cyklus (og ikke kun) i visse kombinationer forekomme fra iteration til iteration. Alt dette resulterer i spildtid, forvirring, nerver, muligvis kundetilfredshed og i sidste ende tabte penge. Selvom vi alle normalt følger den samme gamle rake, tror jeg, at ingen ønsker at genopleve disse øjeblikke igen og igen.

Så vi har gennemgået en udviklingscyklus, og vi ser, at der er problemer, der skal løses. For at gøre dette skal du bruge:

gemme arbejdsresultater bekvemt;
gøre processen med at involvere nye medarbejdere enkel;
forenkle processen med at implementere et udviklingsmiljø;
konfigurere modelversioneringsprocessen;
har en bekvem måde at validere modeller på;
finde et modelstatsstyringsværktøj;
finde en måde at levere modeller til produktionen.

Det er tilsyneladende nødvendigt at komme med en arbejdsgang, der giver dig mulighed for nemt og bekvemt at styre denne livscyklus? Denne praksis kaldes MLOps

MLOps, eller DevOps for machine learning, giver datavidenskab og it-teams mulighed for at samarbejde og øge tempoet i modeludvikling og implementering gennem overvågning, validering og styring af maskinlæringsmodeller.

Du kan æreHvad synes Google-fyrene om alt dette? Fra artiklen er det klart, at MLOps er en ganske omfangsrig ting.

Yderligere i min artikel vil jeg kun beskrive en del af processen. Til implementering vil jeg bruge MLflow-værktøjet, fordi... Dette er et open source-projekt, der kræves en lille mængde kode for at forbinde, og der er integration med populære ml-frameworks. Du kan søge på internettet efter andre værktøjer, såsom Kubeflow, SageMaker, Tog osv., og måske finde et, der passer bedre til dine behov.

"Opbygning" af MLO'er ved at bruge eksemplet med brug af MLFlow-værktøjet

MLFlow er en open source platform til livscyklusstyring af ml-modeller (https://mlflow.org/).

MLflow omfatter fire komponenter:

MLflow Tracking - dækker spørgsmålene om registrering af resultater og parametre, der førte til dette resultat;
MLflow Project - giver dig mulighed for at pakke kode og reproducere den på enhver platform;
MLflow Models - ansvarlig for implementering af modeller til produktion;
MLflow Registry - giver dig mulighed for at gemme modeller og administrere deres tilstand i et centraliseret lager.

MLflow opererer på to enheder:

lanceringen er en fuld cyklus af træning, parametre og målinger, som vi ønsker at registrere efter;
Et eksperiment er et "emne", der løber sammen.

Alle trin i eksemplet er implementeret på Ubuntu 18.04-operativsystemet.

1. Implementer serveren

For at vi nemt kan administrere vores projekt og modtage al den nødvendige information, installerer vi en server. MLflow-sporingsserveren har to hovedkomponenter:

backend-lager - ansvarlig for lagring af information om registrerede modeller (understøtter 4 DBMS'er: mysql, mssql, sqlite og postgresql);
artefaktlager - ansvarlig for lagring af artefakter (understøtter 7 lagermuligheder: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP-server, SFTP-server, NFS, HDFS).

Som artefakt butik For nemheds skyld, lad os tage en sftp-server.

oprette en gruppe
```
$ sudo groupadd sftpg
```

tilføj en bruger og indstil en adgangskode til ham

$ sudo useradd -g sftpg mlflowsftp
$ sudo passwd mlflowsftp

justering af et par adgangsindstillinger

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

tilføj et par linjer til /etc/ssh/sshd_config

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

genstart tjenesten
```
$ sudo systemctl restart sshd
```

Som backend butik Lad os tage 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

For at starte serveren skal du installere følgende python-pakker (jeg anbefaler at oprette et separat virtuelt miljø):

pip install mlflow
pip install pysftp

Lad os starte vores server

$ 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. Tilføj sporing

For at resultaterne af vores træning ikke skal gå tabt, fremtidige generationer af udviklere skal forstå, hvad der skete, og for at ældre kammerater og dig roligt kan analysere læringsprocessen, er vi nødt til at tilføje sporing. Sporing betyder at gemme parametre, metrikker, artefakter og enhver yderligere information om starten af træningen, i vores tilfælde, på serveren.

For eksempel oprettede jeg en lille projekt på github på Keras for at segmentere alt, hvad der er i COCO datasæt. For at tilføje sporing oprettede jeg en fil mlflow_training.py.

Her er de linjer, hvor de mest interessante ting sker:

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)

Her er self.remote_server en lille indpakning over mlflow.tracking metoderne. MlflowClient (jeg lavede det for nemheds skyld), ved hjælp af hvilket jeg opretter et eksperiment og kører det på serveren. Dernæst angiver jeg, hvor lanceringsresultaterne skal flettes (mlflow.set_tracking_uri(self.tracking_uri)). Jeg aktiverer automatisk logning mlflow.keras.autolog(). I øjeblikket understøtter MLflow Tracking automatisk logning for TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Hvis du ikke har fundet dit framework eller bibliotek, så kan du altid logge eksplicit. Vi starter træningen. Registrer tags og inputparametre på fjernserveren.

Et par linjer og du, som alle andre, har adgang til information om alle lanceringer. Fedt nok?

3. Vi udarbejder projektet

Lad os nu gøre det nemt at starte projektet. For at gøre dette skal du tilføje filen MLproject og conda.yaml til projektroden.
ML-projekt

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 Project har flere egenskaber:

Navn - navnet på dit projekt;
Miljø - i mit tilfælde angiver conda_env, at Anaconda bruges til at køre, og afhængighedsbeskrivelsen er i filen conda.yaml;
Entry Points - angiver hvilke filer og med hvilke parametre vi kan køre (alle parametre logges automatisk ved start af træning)

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

Du kan bruge docker som dit runtime-miljø, for flere detaljer henvises til dokumentation.

4. Lad os begynde at træne

Vi kloner projektet og går til projektkataloget:

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

For at køre skal du installere biblioteker

pip install mlflow
pip install pysftp

Fordi i eksemplet bruger jeg conda_env, skal Anaconda være installeret på din computer (men du kan komme uden om dette ved selv at installere alle de nødvendige pakker og lege med startparametrene).

Alle forberedende trin er gennemført, og vi kan begynde at lancere uddannelsen. Fra projektroden:

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

Efter indtastning af kommandoen oprettes der automatisk et conda-miljø, og træningen starter.
I eksemplet ovenfor passerede jeg antallet af epoker for træning, de kategorier, som vi ønsker at segmentere i (du kan se hele listen her) og adressen på vores fjernserver.
En komplet liste over mulige parametre kan findes i MLproject-filen.

5. Evaluer læringsresultater

Efter at have gennemført uddannelsen kan vi gå i browseren til adressen på vores server http://server_host:server_port

Her ser vi en liste over alle forsøg (øverst til venstre), samt information om kørsler (midt). Vi kan se mere detaljerede oplysninger (parametre, metrikker, artefakter og nogle yderligere oplysninger) for hver lancering.

For hver metrik kan vi observere ændringernes historie

De der. I øjeblikket kan vi analysere resultaterne i en "manuel" tilstand, og du kan også opsætte automatisk validering ved hjælp af MLflow API.

6. Registrer modellen

Efter at vi har analyseret vores model og besluttet, at den er klar til kamp, fortsætter vi med at registrere den, til dette vælger vi den lancering, vi har brug for (som vist i forrige afsnit) og går ned.

Når vi har givet vores model et navn, har den en version. Hvis du gemmer en anden model med samme navn, vil versionen automatisk blive opgraderet.

For hver model kan vi tilføje en beskrivelse og vælge en af tre tilstande (Staging, Production, Archived); efterfølgende kan vi ved hjælp af API'en få adgang til disse tilstande, hvilket sammen med versionering giver yderligere fleksibilitet.

Vi har også nem adgang til alle modeller

og deres versioner

Som i det foregående afsnit kan alle handlinger udføres ved hjælp af API.

7. Implementer modellen

På dette stadium har vi allerede en trænet (keras) model. Et eksempel på hvordan du kan bruge det:

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

Her er self.registry igen en lille indpakning over mlflow.tracking.MlflowClient, for nemheds skyld. Pointen er, at jeg tilgår en ekstern server og leder efter en model der med det angivne navn og den seneste produktionsversion. Dernæst downloader jeg artefakten lokalt til mappen ./model og bygger modellen fra denne mappe mlflow.keras.load_model(local_path). Nu kan vi bruge vores model. CV (ML) udviklere kan nemt forbedre modellen og udgive nye versioner.

Afslutningsvis

Jeg præsenterede et system, der tillader:

centralt lagre information om ML-modeller, træningsfremskridt og resultater;
hurtigt implementere et udviklingsmiljø;
overvåge og analysere fremskridtene i arbejdet med modeller;
det er praktisk at versionere og styre modellernes tilstand;
Det er nemt at implementere de resulterende modeller.

Dette eksempel er et stykke legetøj og tjener som udgangspunkt for at bygge dit eget system, hvilket kan omfatte automatisering af evaluering af resultater og registrering af modeller (hhv. punkt 5 og 6) eller du vil tilføje versionering af datasæt, eller måske noget andet ? Pointen, jeg prøvede at gøre, er, at du har brug for MLOps som helhed, MLflow er kun et middel til at nå målet.

Skriv hvilke problemer du stødte på, som jeg ikke viste?
Hvad vil du tilføje til systemet for at få det til at opfylde dine behov?
Hvilke værktøjer og tilgange bruger du til at løse alle eller dele af problemerne?

PS jeg vil efterlade et par links:
github projekt - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Min arbejdsmail for spørgsmål - [e-mail beskyttet]

Vores virksomhed afholder med jævne mellemrum forskellige arrangementer for IT-specialister, for eksempel: den 8. juli kl. 19:00 Moskva-tid vil der være et CV-møde i et online format, hvis du er interesseret, kan du deltage, tilmelding her .

Kilde: www.habr.com

MLOps - Kogebog, kapitel 1