MLOps - Kuharska knjiga, 1. poglavlje

Zdravo svima! Ja sam CV programer u CROC-u. Projekte iz oblasti CV-a realizujemo već 3 godine. Za to vrijeme radili smo dosta stvari, na primjer: pratili smo vozače da tokom vožnje ne piju, ne puše, ne pričaju telefonom, gledaju u cestu, a ne u snove ili oblake ; Zabilježili smo ljude koji voze u namjenskim trakama i zauzimaju nekoliko parking mjesta; osiguralo da radnici nose kacige, rukavice itd.; identifikovao zaposlenog koji želi da uđe u objekat; Prebrojali smo sve što smo mogli.

Zašto sve ovo radim?

U procesu realizacije projekata nailazimo na neravnine, dosta neravnina, neke probleme sa kojima ste ili upoznati ili ćete se upoznati u budućnosti.

Hajde da simuliramo situaciju

Zamislimo da smo se zaposlili u mladoj kompaniji „N“, čije su aktivnosti vezane za ML. Radimo na ML (DL, CV) projektu, zatim iz nekog razloga prelazimo na drugi posao, uglavnom napravimo pauzu i vraćamo se svom ili tuđem neuronu.

1. Dolazi trenutak istine, morate se nekako sjetiti gdje ste stali, koje ste hiperparametre pokušali i, što je najvažnije, do kakvih su rezultata doveli. Može postojati mnogo opcija ko je pohranio informacije o svim pokretanjima: u glavi, konfiguracijama, notepadu, u radnom okruženju u oblaku. Slučajno sam video opciju kada su hiperparametri pohranjeni kao komentarisani redovi u kodu, generalno, fensi. Sada zamislite da se niste vratili svom projektu, već projektu osobe koja je napustila kompaniju i naslijedili ste kod i model koji se zove model_1.pb. Da biste upotpunili sliku i prenijeli svu bol, zamislimo da ste i vi specijalista početnik.
2. Nastavi. Da bismo pokrenuli kod, mi i svi koji će raditi s njim moramo stvoriti okruženje. Često se dešava da ga iz nekog razloga nisu ostavili u naslijeđe. Ovo također može postati netrivijalan zadatak. Ne želite da gubite vreme na ovaj korak, zar ne?
3. Obučavamo model (na primjer, detektor automobila). Dolazimo do tačke kada postaje jako dobro – vrijeme je da sačuvamo rezultat. Nazovimo ga car_detection_v1.pb. Zatim treniramo još jednu - car_detection_v2.pb. Nešto kasnije, naše kolege ili mi sami predajemo sve više i više, koristeći različite arhitekture. Kao rezultat toga, formira se gomila artefakata, informacije o kojima se moraju mukotrpno prikupljati (ali to ćemo učiniti kasnije, jer za sada imamo prioritetnije stvari).
4. OK, sada je sve gotovo! Imamo model! Možemo li početi trenirati sljedeći model, razvijati arhitekturu za rješavanje novog problema, ili možemo otići na čaj? A ko će rasporediti?

Identifikacija problema

Rad na projektu ili proizvodu je posao mnogih ljudi. I vremenom ljudi odlaze i dolaze, ima više projekata, a sami projekti postaju složeniji. Na ovaj ili onaj način, situacije iz gore opisanog ciklusa (i ne samo) u određenim kombinacijama će se javljati iz iteracije u iteraciju. Sve to rezultira gubitkom vremena, konfuzijom, živcima, eventualno nezadovoljstvom kupaca i na kraju izgubljenim novcem. Iako svi obično pratimo istu staru grabu, vjerujem da niko ne želi da proživljava te trenutke iznova i iznova.

Dakle, prošli smo jedan razvojni ciklus i vidimo da ima problema koje treba riješiti. Da biste to uradili potrebno vam je:

• prikladno pohranjivati ​​rezultate rada;
• pojednostaviti proces uključivanja novih zaposlenih;
• pojednostaviti proces implementacije razvojnog okruženja;
• konfigurirati proces verzioniranja modela;
• imaju zgodan način za validaciju modela;
• pronaći alat za upravljanje stanjem modela;
• pronaći način da isporučite modele u proizvodnju.

Očigledno je potrebno osmisliti tok posla koji bi vam omogućio da lako i praktično upravljate ovim životnim ciklusom? Ova praksa se zove MLOps

MLOps, ili DevOps za mašinsko učenje, omogućava timovima za nauku podataka i IT da sarađuju i povećaju tempo razvoja i implementacije modela kroz praćenje, validaciju i upravljanje modelima mašinskog učenja.

Možete čitajŠta Guglovi misle o svemu ovome? Iz članka je jasno da je MLOps prilično obimna stvar.

Dalje u svom članku opisat ću samo dio procesa. Za implementaciju ću koristiti alat MLflow, jer... Ovo je projekat otvorenog koda, potrebna je mala količina koda za povezivanje i postoji integracija sa popularnim ml okvirima. Možete pretražiti internet za drugim alatima, kao što su Kubeflow, SageMaker, Trains, itd., i možda pronaći onaj koji više odgovara vašim potrebama.

“Izgradnja” MLOps-a na primjeru korištenja alata MLFlow

MLFlow je platforma otvorenog koda za upravljanje životnim ciklusom ml modela (https://mlflow.org/).

MLflow uključuje četiri komponente:

• MLflow Tracking - pokriva pitanja snimanja rezultata i parametara koji su doveli do ovog rezultata;
• MLflow Project - omogućava vam da pakujete kod i reprodukujete ga na bilo kojoj platformi;
• MLflow Models - odgovoran za implementaciju modela u proizvodnju;
• MLflow Registry - omogućava vam pohranjivanje modela i upravljanje njihovim stanjem u centraliziranom spremištu.

MLflow radi na dva entiteta:

• lansiranje je puni ciklus obuke, parametara i metrika po kojima želimo da se registrujemo;
• Eksperiment je „tema“ koja se odvija zajedno.

Svi koraci iz primjera implementirani su na Ubuntu 18.04 operativni sistem.

1. Postavite server

Kako bismo lakše upravljali našim projektom i dobili sve potrebne informacije, postavićemo server. MLflow server za praćenje ima dvije glavne komponente:

• backend store - odgovoran za skladištenje informacija o registrovanim modelima (podržava 4 DBMS-a: mysql, mssql, sqlite i postgresql);
• skladište artefakata - odgovorno za skladištenje artefakata (podržava 7 opcija skladištenja: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP server, SFTP server, NFS, HDFS).

Kao prodavnica artefakata Radi jednostavnosti, uzmimo sftp server.

• kreirajte grupu

  $ sudo groupadd sftpg

• dodajte korisnika i postavite mu lozinku

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• podešavanje nekoliko postavki pristupa

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

• dodajte nekoliko redova u /etc/ssh/sshd_config

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

• ponovo pokrenite uslugu

  $ sudo systemctl restart sshd

Kao backend store Uzmimo 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

Da biste pokrenuli server, morate instalirati sljedeće python pakete (preporučujem da napravite zasebno virtualno okruženje):

pip install mlflow
pip install pysftp

Pokrenimo naš 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. Dodajte praćenje

Da se rezultati naše obuke ne bi izgubili, buduće generacije programera shvatile šta se dešava, a da bi stariji drugovi i vi mogli mirno analizirati proces učenja, potrebno je da dodamo praćenje. Praćenje znači čuvanje parametara, metrike, artefakata i svih dodatnih informacija o početku treninga, u našem slučaju, na serveru.

Na primjer, napravio sam mali projekat na githubu na Kerasu za segmentiranje svega što je u COCO skup podataka. Da bih dodao praćenje, kreirao sam datoteku mlflow_training.py.

Evo redova u kojima se dešavaju najzanimljivije 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)

Ovdje self.remote_server je mali omot iznad metoda mlflow.tracking. MlflowClient (napravio sam ga radi praktičnosti), uz pomoć kojeg kreiram eksperiment i pokrećem ga na serveru. Zatim naznačavam gdje se rezultati pokretanja trebaju spojiti (mlflow.set_tracking_uri(self.tracking_uri)). Omogućavam automatsko evidentiranje mlflow.keras.autolog(). Trenutno MLflow Tracking podržava automatsko evidentiranje za TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Ako niste pronašli svoj okvir ili biblioteku, uvijek se možete eksplicitno prijaviti. Počinjemo sa obukom. Registrirajte oznake i ulazne parametre na udaljenom serveru.

Nekoliko redova i vi, kao i svi ostali, imate pristup informacijama o svim lansiranjima. Cool?

3. Izrađujemo projekat

Sada ćemo olakšati pokretanje projekta poput ljuštenja krušaka. Da biste to učinili, dodajte datoteku MLproject i conda.yaml u korijen 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}"

MLflow Project ima nekoliko svojstava:

• Naziv - naziv vašeg projekta;
• Okruženje - u mom slučaju, conda_env označava da se Anaconda koristi za pokretanje, a opis zavisnosti je u datoteci conda.yaml;
• Entry Points - označava koje fajlove i sa kojim parametrima možemo pokrenuti (svi parametri se automatski evidentiraju na poč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

Možete koristiti docker kao svoje okruženje za izvršavanje, za više detalja pogledajte dokumentaciju.

4. Počnimo sa treningom

Kloniramo projekat i idemo u direktorij projekta:

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

Za pokretanje morate instalirati biblioteke

pip install mlflow
pip install pysftp

Jer u primeru koji koristim conda_env, Anaconda mora biti instalirana na vašem računaru (ali ovo možete zaobići tako što ćete sami instalirati sve potrebne pakete i igrati se sa parametrima pokretanja).

Svi pripremni koraci su završeni i možemo početi sa obukom. Iz korijena projekta:

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

Nakon unosa komande, konda okruženje će se automatski kreirati i obuka će početi.
U gornjem primjeru prenio sam broj epoha za obuku, kategorije u koje želimo segmentirati (možete vidjeti kompletnu listu ovdje) i adresu našeg udaljenog servera.
Kompletna lista mogućih parametara može se naći u datoteci MLproject.

5. Vrednovati rezultate učenja

Nakon završene obuke možemo u pretraživaču otići na adresu našeg servera http://server_host:server_port

Ovdje vidimo listu svih eksperimenata (gore lijevo), kao i informacije o izvođenju (u sredini). Možemo vidjeti detaljnije informacije (parametre, metrike, artefakte i neke dodatne informacije) za svako lansiranje.

Za svaku metriku možemo posmatrati istoriju promena

One. Trenutno možemo analizirati rezultate u “ručnom” načinu rada, a možete podesiti i automatsku validaciju koristeći MLflow API.

6. Registrirajte model

Nakon što smo analizirali naš model i odlučili da je spreman za bitku, nastavljamo sa registracijom, za to biramo lansiranje koje nam je potrebno (kao što je prikazano u prethodnom paragrafu) i idemo dolje.

Nakon što damo ime našem modelu, on ima verziju. Ako sačuvate drugi model sa istim imenom, verzija će se automatski nadograditi.

Za svaki model možemo dodati opis i odabrati jedno od tri stanja (Staging, Production, Archived); naknadno, koristeći API, možemo pristupiti tim stanjima, što uz verzioniranje pruža dodatnu fleksibilnost.

Takođe imamo lak pristup svim modelima

i njihove verzije

Kao iu prethodnom paragrafu, sve operacije se mogu obaviti pomoću API-ja.

7. Postavite model

U ovoj fazi već imamo obučeni (keras) model. Primjer kako ga možete koristiti:

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

Ovdje self.registry je opet mali omot iznad mlflow.tracking.MlflowClienta, radi praktičnosti. Poenta je da pristupam udaljenom serveru i tamo tražim model sa navedenim imenom i najnovijom produkcijskom verzijom. Zatim, preuzimam artefakt lokalno u fasciklu ./model i pravim model iz ovog direktorijuma mlflow.keras.load_model(local_path). Sada možemo koristiti naš model. CV (ML) programeri mogu lako poboljšati model i objaviti nove verzije.

U zaključku

Predstavio sam sistem koji omogućava:

• centralno pohranjuju informacije o modelima ML, napretku obuke i rezultatima;
• brzo implementirati razvojno okruženje;
• prati i analizira tok rada na modelima;
• pogodan je za verziju i upravljanje stanjem modela;
• Lako je implementirati rezultirajuće modele.

Ovaj primjer je igračka i služi kao početna tačka za izgradnju vlastitog sistema, koji može uključivati ​​automatizaciju evaluacije rezultata i registraciju modela (tačke 5 i 6, respektivno) ili ćete dodati verzioniranje skupova podataka, ili možda nešto drugo? Ono što sam pokušavao da kažem je da su vam potrebni MLOps kao celina, MLflow je samo sredstvo za postizanje cilja.

Napišite na koje probleme ste naišli a nisam prikazao?
Šta biste dodali sistemu da bi zadovoljio vaše potrebe?
Koje alate i pristupe koristite za rješavanje svih ili dijela problema?

PS ostavicu par linkova:
github projekat - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
Moj radni email za pitanja - [email zaštićen]

Naša kompanija povremeno organizuje razne događaje za IT stručnjake, na primer: 8. jula u 19:00 po moskovskom vremenu održaće se CV sastanak u onlajn formatu, ako ste zainteresovani, možete učestvovati, registracija ovdje .

izvor: www.habr.com