MLOps - Kokbok, kapitel 1

Hej alla! Jag är CV-utvecklare på CROC. Vi har genomfört projekt inom CV i 3 år nu. Under den här tiden gjorde vi många saker, till exempel: vi övervakade förare så att de under körningen inte drack, rökte inte, pratade inte i telefon, tittade på vägen och inte på drömmar eller på molnen ; Vi spelade in personer som kör i dedikerade körfält och tar upp flera parkeringsplatser; säkerställde att arbetare bar hjälmar, handskar etc.; identifierat en anställd som vill komma in i anläggningen; Vi räknade allt vi kunde.

Vad gör jag allt detta för?

I processen med att genomföra projekt stöter vi på stötar, många stötar, några av problemen du antingen känner till eller kommer att bekanta dig med i framtiden.

Modellera situationen

Låt oss föreställa oss att vi fick jobb på ett ungt företag "N", vars verksamhet är relaterade till ML. Vi arbetar med ett ML-projekt (DL, CV), sedan byter vi av någon anledning till ett annat jobb, tar vanligtvis en paus och återgår till vår egen eller någon annans neuron.

1. Sanningens ögonblick kommer, du måste på något sätt komma ihåg var du slutade, vilka hyperparametrar du försökte och, viktigast av allt, vilka resultat de ledde till. Det kan finnas många alternativ för vem som lagrat information vid alla lanseringar: i huvudet, konfigurationer, anteckningsblock, i en arbetsmiljö i molnet. Jag råkade se ett alternativ när hyperparametrar lagrades som kommenterade rader i koden, i allmänhet en fantasi. Föreställ dig nu att du inte återvände till ditt projekt, utan till projektet för en person som lämnade företaget och du ärvde en kod och en modell som heter model_1.pb. För att komplettera bilden och förmedla all smärta, låt oss föreställa oss att du också är en nybörjarspecialist.
2. Varsågod. För att köra koden behöver vi och alla som ska arbeta med den skapa en miljö. Det händer ofta att de av någon anledning inte lämnade honom som vårt arv. Detta kan också bli en icke-trivial uppgift. Du vill inte slösa tid på det här steget, eller hur?
3. Vi tränar en modell (till exempel en bildetektor). Vi kommer till den punkt där det blir väldigt bra – det är dags att spara resultatet. Låt oss kalla det car_detection_v1.pb. Sedan tränar vi en till - car_detection_v2.pb. En tid senare undervisar våra kollegor eller vi själva mer och mer med olika arkitekturer. Som ett resultat bildas ett gäng artefakter, information om vilka måste samlas in noggrant (men vi kommer att göra detta senare, för nu har vi fler prioriterade frågor).
4. OK det är över nu! Vi har en modell! Kan vi börja träna nästa modell, utveckla en arkitektur för att lösa ett nytt problem, eller kan vi gå och dricka lite te? Och vem ska distribuera?

Identifiera problem

Att arbeta med ett projekt eller en produkt är många människors arbete. Och med tiden går folk och kommer, det blir fler projekt och själva projekten blir mer komplexa. På ett eller annat sätt kommer situationer från cykeln som beskrivs ovan (och inte bara) i vissa kombinationer att inträffa från iteration till iteration. Allt detta resulterar i bortkastad tid, förvirring, nerver, möjligen missnöje hos kunder och i slutändan förlorade pengar. Även om vi alla brukar följa samma gamla rake, tror jag att ingen vill återuppleva dessa ögonblick om och om igen.

Så vi har gått igenom en utvecklingscykel och vi ser att det finns problem som måste lösas. För att göra detta behöver du:

• lagra arbetsresultat bekvämt;
• göra processen att involvera nya medarbetare enkel;
• förenkla processen för att distribuera en utvecklingsmiljö;
• konfigurera modellversionsprocessen;
• ha ett bekvämt sätt att validera modeller;
• hitta ett modelltillståndshanteringsverktyg;
• hitta ett sätt att leverera modeller till produktion.

Tydligen är det nödvändigt att komma med ett arbetsflöde som gör att du enkelt och bekvämt kan hantera denna livscykel? Denna praxis kallas MLOps

MLOps, eller DevOps för maskininlärning, tillåter datavetenskap och IT-team att samarbeta och öka takten i modellutveckling och implementering genom övervakning, validering och styrning av maskininlärningsmodeller.

Du kan att läsaVad tycker Google-killarna om allt detta? Från artikeln är det tydligt att MLOps är en ganska omfattande sak.

Vidare i min artikel kommer jag att beskriva endast en del av processen. För implementering kommer jag att använda MLflow-verktyget, eftersom... Detta är ett projekt med öppen källkod, en liten mängd kod krävs för att ansluta och det finns integration med populära ml-ramverk. Du kan söka på Internet efter andra verktyg, som Kubeflow, SageMaker, Tåg, etc. och kanske hitta ett som bättre passar dina behov.

"Bygga" MLOps med hjälp av exemplet med att använda MLFlow-verktyget

MLFlow är en öppen källkodsplattform för livscykelhantering av ml-modeller (https://mlflow.org/).

MLflow innehåller fyra komponenter:

• MLflow Tracking - täcker frågorna om att registrera resultat och parametrar som ledde till detta resultat;
• MLflow Project - låter dig paketera kod och reproducera den på vilken plattform som helst;
• MLflow Models - ansvarig för att distribuera modeller till produktion;
• MLflow Registry - låter dig lagra modeller och hantera deras tillstånd i ett centraliserat arkiv.

MLflow verkar på två enheter:

• lansering är en hel cykel av utbildning, parametrar och mätvärden som vi vill registrera oss efter;
• Ett experiment är ett "ämne" som går ihop.

Alla steg i exemplet är implementerade på operativsystemet Ubuntu 18.04.

1. Distribuera servern

För att vi enkelt ska kunna hantera vårt projekt och få all nödvändig information kommer vi att distribuera en server. MLflow-spårningsserver har två huvudkomponenter:

• backend store - ansvarig för att lagra information om registrerade modeller (stöder 4 DBMS: mysql, mssql, sqlite och postgresql);
• artefaktbutik - ansvarig för att lagra artefakter (stöder 7 lagringsalternativ: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP-server, SFTP-server, NFS, HDFS).

Eftersom artefaktbutik För enkelhetens skull, låt oss ta en sftp-server.

• skapa en grupp

  $ sudo groupadd sftpg

• lägg till en användare och ställ in ett lösenord för honom

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• justera ett par åtkomstinställningar

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

• lägg till några rader i /etc/ssh/sshd_config

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

• starta om tjänsten

  $ sudo systemctl restart sshd

Eftersom backend butik Låt oss ta 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

För att starta servern måste du installera följande python-paket (jag rekommenderar att du skapar en separat virtuell miljö):

pip install mlflow
pip install pysftp

Låt oss starta vår 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. Lägg till spårning

För att resultaten av vår utbildning inte ska gå förlorade, framtida generationer av utvecklare ska förstå vad som hände och för att äldre kamrater och du lugnt ska kunna analysera inlärningsprocessen måste vi lägga till spårning. Spårning innebär att spara parametrar, mätvärden, artefakter och all ytterligare information om träningsstart, i vårt fall, på servern.

Till exempel skapade jag en liten projekt på github på Keras för att segmentera allt som finns i COCO-datauppsättning. För att lägga till spårning skapade jag filen mlflow_training.py.

Här är raderna där de mest intressanta sakerna händer:

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)

Här är self.remote_server ett litet omslag över mlflow.tracking-metoderna. MlflowClient (jag gjorde den för enkelhets skull), med hjälp av vilken jag skapar ett experiment och kör det på servern. Därefter anger jag var lanseringsresultaten ska slås samman (mlflow.set_tracking_uri(self.tracking_uri)). Jag aktiverar automatisk loggning mlflow.keras.autolog(). För närvarande stöder MLflow Tracking automatisk loggning för TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Om du inte har hittat ditt ramverk eller bibliotek kan du alltid logga explicit. Vi börjar träna. Registrera taggar och inmatningsparametrar på fjärrservern.

Ett par rader och du, som alla andra, har tillgång till information om alla lanseringar. Häftigt?

3. Vi ritar upp projektet

Låt oss nu göra det enkelt att starta projektet. För att göra detta, lägg till filen MLproject och conda.yaml till projektroten.
MLprojekt

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 flera egenskaper:

• Namn - namnet på ditt projekt;
• Miljö - i mitt fall indikerar conda_env att Anaconda används för att köra och beroendebeskrivningen finns i filen conda.yaml;
• Entry Points - indikerar vilka filer och med vilka parametrar vi kan köra (alla parametrar loggas automatiskt när träningen påbörjas)

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 använda docker som din runtime-miljö, för mer information, se dokumentation.

4. Låt oss börja träna

Vi klonar projektet och går till projektkatalogen:

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

För att köra måste du installera bibliotek

pip install mlflow
pip install pysftp

Därför att i exemplet jag använder conda_env måste Anaconda vara installerat på din dator (men du kan komma runt detta genom att installera alla nödvändiga paket själv och spela med startparametrarna).

Alla förberedande steg är genomförda och vi kan börja lansera utbildningen. Från projektroten:

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

Efter inmatning av kommandot skapas en conda-miljö automatiskt och träningen startar.
I exemplet ovan passerade jag antalet epoker för träning, kategorierna som vi vill segmentera i (du kan se hela listan här) och adressen till vår fjärrserver.
En komplett lista över möjliga parametrar finns i MLproject-filen.

5. Utvärdera läranderesultat

Efter avslutad utbildning kan vi gå i webbläsaren till adressen till vår server http://server_host:server_port

Här ser vi en lista över alla experiment (överst till vänster), samt information om körningar (mitten). Vi kan se mer detaljerad information (parametrar, mätvärden, artefakter och viss ytterligare information) för varje lansering.

För varje mätvärde kan vi observera förändringshistoriken

De där. För tillfället kan vi analysera resultaten i ett "manuellt" läge, och du kan också ställa in automatisk validering med MLflow API.

6. Registrera modellen

Efter att vi har analyserat vår modell och beslutat att den är redo för strid fortsätter vi att registrera den, för detta väljer vi den lansering vi behöver (som visas i föregående stycke) och går ner.

Efter att vi gett vår modell ett namn har den en version. Om du sparar en annan modell med samma namn kommer versionen automatiskt att uppgraderas.

För varje modell kan vi lägga till en beskrivning och välja ett av tre tillstånd (Staging, Production, Archived); därefter kan vi, med hjälp av API:t, komma åt dessa tillstånd, vilket tillsammans med versionshantering ger ytterligare flexibilitet.

Vi har även enkel tillgång till alla modeller

och deras versioner

Som i föregående stycke kan alla operationer göras med hjälp av API:et.

7. Distribuera modellen

I detta skede har vi redan en utbildad (keras) modell. Ett exempel på hur du kan använda 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

Här är self.registry återigen ett litet omslag över mlflow.tracking.MlflowClient, för enkelhetens skull. Poängen är att jag kommer åt en fjärrserver och letar efter en modell där med det angivna namnet och den senaste produktionsversionen. Därefter laddar jag ner artefakten lokalt till mappen ./model och bygger modellen från den här katalogen mlflow.keras.load_model(local_path). Nu kan vi använda vår modell. CV (ML)-utvecklare kan enkelt förbättra modellen och publicera nya versioner.

Sammanfattningsvis

Jag presenterade ett system som tillåter:

• centralt lagra information om ML-modeller, utbildningsframsteg och resultat;
• snabbt distribuera en utvecklingsmiljö;
• övervaka och analysera framstegen i arbetet med modeller;
• det är bekvämt att versionera och hantera modellernas tillstånd;
• Det är lätt att distribuera de resulterande modellerna.

Det här exemplet är en leksak och fungerar som utgångspunkt för att bygga ett eget system, vilket kan inkludera automatisering av utvärdering av resultat och registrering av modeller (punkt 5 respektive 6) eller så kommer du att lägga till versionshantering av datamängder, eller kanske något annat? Poängen jag försökte göra är att du behöver MLOps som helhet, MLflow är bara ett sätt att nå ett mål.

Skriv vilka problem du stött på som jag inte visade?
Vad skulle du lägga till systemet för att det ska möta dina behov?
Vilka verktyg och tillvägagångssätt använder du för att lösa hela eller delar av problemen?

PS Jag lämnar ett par länkar:
github projekt - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Min arbetsmail för frågor - [e-postskyddad]

Vårt företag är regelbundet värd för olika evenemang för IT-specialister, till exempel: den 8 juli kl 19:00 Moskva-tid kommer det att hållas en CV-träff i onlineformat, om du är intresserad kan du delta, registrering här .

Källa: will.com