Dag Allemaal! Ik ben CV-ontwikkelaar bij CROC. Al 3 jaar voeren wij projecten uit op het gebied van CV. Gedurende deze tijd hebben we bijvoorbeeld veel dingen gedaan: we hielden chauffeurs in de gaten, zodat ze tijdens het rijden niet dronken, niet rookten, niet aan de telefoon praatten, naar de weg keken en niet naar dromen of naar de wolken. ; We hebben mensen geregistreerd die op speciale rijstroken rijden en meerdere parkeerplaatsen in beslag nemen; zorgde ervoor dat werknemers helmen, handschoenen, enz. droegen; een werknemer geïdentificeerd die de faciliteit wil betreden; We telden alles wat we konden.
Waar doe ik dit allemaal voor?
Tijdens het implementeren van projecten komen we hobbels tegen, heel veel hobbels, sommige van de problemen waarmee u bekend bent of waar u in de toekomst kennis mee zult maken.
Laten we de situatie simuleren
Laten we ons voorstellen dat we een baan hebben gekregen bij een jong bedrijf “N”, waarvan de activiteiten verband houden met ML. We werken aan een ML-project (DL, CV), en om de een of andere reden schakelen we over naar een andere baan, nemen meestal een pauze en keren terug naar ons eigen neuron of dat van iemand anders.
- Het moment van de waarheid komt, je moet op de een of andere manier onthouden waar je bent gestopt, welke hyperparameters je hebt geprobeerd en, belangrijker nog, tot welke resultaten ze hebben geleid. Er kunnen veel opties zijn voor wie informatie over alle lanceringen heeft opgeslagen: in het hoofd, configuraties, notitieblok, in een werkomgeving in de cloud. Ik zag toevallig een optie wanneer hyperparameters werden opgeslagen als commentaarregels in de code, over het algemeen een fantasie. Stel je nu voor dat je niet terugkeert naar je project, maar naar het project van iemand die het bedrijf heeft verlaten en dat je een code en een model hebt geërfd met de naam model_1.pb. Om het plaatje compleet te maken en alle pijn over te brengen, stellen we ons voor dat je ook een beginnersspecialist bent.
- Doe Maar. Om de code uit te voeren, moeten wij en iedereen die ermee gaat werken een omgeving creëren. Het komt vaak voor dat ze hem om de een of andere reden niet als onze erfenis hebben nagelaten. Dit kan ook een niet-triviale taak worden. Je wilt geen tijd verspillen aan deze stap, toch?
- We trainen een model (bijvoorbeeld een autodetector). We komen op het punt waarop het heel goed wordt – het is tijd om het resultaat op te slaan. Laten we het car_detection_v1.pb noemen. Daarna trainen we er nog een: car_detection_v2.pb. Enige tijd later geven onze collega's of wijzelf steeds meer les, waarbij we verschillende architecturen gebruiken. Als gevolg hiervan worden een aantal artefacten gevormd, waarvan de informatie nauwgezet moet worden verzameld (maar we zullen dit later doen, omdat we voorlopig meer prioriteit hebben).
- Oké, het is allemaal voorbij. Nu! Wij hebben een model! Kunnen we beginnen met het trainen van het volgende model, het ontwikkelen van een architectuur om een nieuw probleem op te lossen, of kunnen we thee gaan drinken? En wie gaat inzetten?
Problemen identificeren
Werken aan een project of product is het werk van veel mensen. En na verloop van tijd gaan mensen weg en komen er meer projecten en worden de projecten zelf complexer. Op de een of andere manier zullen situaties uit de hierboven beschreven cyclus (en niet alleen) in bepaalde combinaties van iteratie tot iteratie voorkomen. Dit alles resulteert in tijdverspilling, verwarring, zenuwen, mogelijk ontevredenheid van klanten en uiteindelijk geldverlies. Hoewel we meestal allemaal dezelfde lijn volgen, geloof ik dat niemand deze momenten steeds opnieuw wil beleven.
We hebben dus één ontwikkelingscyclus doorlopen en we zien dat er problemen zijn die moeten worden opgelost. Om dit te doen heb je nodig:
- werkresultaten gemakkelijk opslaan;
- maak het proces van het betrekken van nieuwe medewerkers eenvoudig;
- het proces van het inzetten van een ontwikkelomgeving vereenvoudigen;
- het modelversieproces configureren;
- een handige manier hebben om modellen te valideren;
- een modelstaatbeheertool vinden;
- een manier vinden om modellen aan productie te leveren.
Blijkbaar is het nodig om een workflow te bedenken waarmee je deze levenscyclus eenvoudig en overzichtelijk kunt beheren? Deze praktijk wordt MLOps genoemd
Met MLOps, of DevOps voor machine learning, kunnen datawetenschaps- en IT-teams samenwerken en het tempo van de modelontwikkeling en -implementatie verhogen door monitoring, validatie en beheer van machine learning-modellen.
Kun je Wat vinden de Google-jongens hiervan? Uit het artikel wordt duidelijk dat MLOps nogal omvangrijk is.
Verderop in mijn artikel zal ik slechts een deel van het proces beschrijven. Voor de implementatie gebruik ik de tool MLflow, omdat... Dit is een open-sourceproject, er is een kleine hoeveelheid code nodig om verbinding te maken en er is integratie met populaire ml-frameworks. U kunt op internet zoeken naar andere tools, zoals Kubeflow, SageMaker, Trains, enz., en misschien er een vinden die beter bij uw behoeften past.
MLOps 'bouwen' met behulp van het voorbeeld van het gebruik van de MLFlow-tool
MLFlow is een open source platform voor levenscyclusbeheer van ml-modellen ().
MLflow omvat vier componenten:
- MLflow Tracking - behandelt de problemen van het vastleggen van resultaten en parameters die tot dit resultaat hebben geleid;
- MLflow Project - hiermee kunt u code verpakken en op elk platform reproduceren;
- MLflow Models - verantwoordelijk voor het implementeren van modellen naar productie;
- MLflow Registry - hiermee kunt u modellen opslaan en hun status beheren in een gecentraliseerde repository.
MLflow werkt op twee entiteiten:
- lancering is een volledige cyclus van training, parameters en statistieken waarmee we ons willen registreren;
- Een experiment is een ‘onderwerp’ dat door elkaar loopt.
Alle stappen uit het voorbeeld zijn geïmplementeerd op het Ubuntu 18.04-besturingssysteem.
1. Implementeer de server
Om ons project eenvoudig te kunnen beheren en alle benodigde informatie te kunnen ontvangen, zullen we een server inzetten. De MLflow-trackingserver heeft twee hoofdcomponenten:
- backend store - verantwoordelijk voor het opslaan van informatie over geregistreerde modellen (ondersteunt 4 DBMS'en: mysql, mssql, sqlite en postgresql);
- artefactopslag - verantwoordelijk voor het opslaan van artefacten (ondersteunt 7 opslagopties: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP-server, SFTP-server, NFS, HDFS).
De artefact winkel Voor de eenvoud nemen we een sftp-server.
- een groep maken
$ sudo groupadd sftpg - voeg een gebruiker toe en stel een wachtwoord voor hem in
$ sudo useradd -g sftpg mlflowsftp $ sudo passwd mlflowsftp - een aantal toegangsinstellingen aanpassen
$ sudo mkdir -p /data/mlflowsftp/upload $ sudo chown -R root.sftpg /data/mlflowsftp $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload - voeg een paar regels toe aan /etc/ssh/sshd_config
Match Group sftpg ChrootDirectory /data/%u ForceCommand internal-sftp - start de dienst opnieuw
$ sudo systemctl restart sshd
De backend winkel Laten we postgresql nemen.
$ 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_dbOm de server te starten, moet je de volgende Python-pakketten installeren (ik raad aan een aparte virtuele omgeving te maken):
pip install mlflow
pip install pysftpLaten we onze server starten
$ 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_port2. Voeg tracking toe
Om ervoor te zorgen dat de resultaten van onze training niet verloren gaan, dat toekomstige generaties ontwikkelaars begrijpen wat er gebeurt, en dat oudere kameraden en jij het leerproces rustig kunnen analyseren, moeten we tracking toevoegen. Tracking betekent het opslaan van parameters, statistieken, artefacten en eventuele aanvullende informatie over het begin van de training, in ons geval, op de server.
Ik heb bijvoorbeeld een kleine gemaakt op Keras voor het segmenteren van alles wat erin zit . Om tracking toe te voegen, heb ik een bestand mlflow_training.py gemaakt.
Dit zijn de regels waar de meest interessante dingen gebeuren:
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)Hier is self.remote_server een kleine verpakking over de mlflow.tracking-methoden. MlflowClient (ik heb het voor het gemak gemaakt), met behulp waarvan ik een experiment maak en op de server uitvoer. Vervolgens geef ik aan waar de startresultaten moeten worden samengevoegd (mlflow.set_tracking_uri(self.tracking_uri)). Ik schakel automatisch loggen mlflow.keras.autolog() in. Momenteel ondersteunt MLflow Tracking automatische logboekregistratie voor TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Als u uw framework of bibliotheek niet hebt gevonden, kunt u altijd expliciet inloggen. We starten met trainen. Registreer tags en voer parameters in op de externe server.
Een paar regels en u heeft, net als iedereen, toegang tot informatie over alle lanceringen. Koel?
3. Wij stellen het project op
Laten we het nu gemakkelijk maken om het project te starten. Om dit te doen, voegt u het bestand MLproject en conda.yaml toe aan de hoofdmap van het project.
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 heeft verschillende eigenschappen:
- Naam - de naam van uw project;
- Omgeving - in mijn geval geeft conda_env aan dat Anaconda wordt gebruikt om te worden uitgevoerd en dat de afhankelijkheidsbeschrijving in het bestand conda.yaml staat;
- Entry Points - geeft aan welke bestanden en met welke parameters we kunnen draaien (alle parameters worden automatisch geregistreerd bij het starten van de training)
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.0U kunt docker gebruiken als uw runtime-omgeving. Raadpleeg voor meer informatie .
4. Laten we beginnen met trainen
We klonen het project en gaan naar de projectmap:
git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/Om te kunnen werken, moet u bibliotheken installeren
pip install mlflow
pip install pysftpOmdat in het voorbeeld dat ik conda_env gebruik, moet Anaconda op je computer zijn geïnstalleerd (maar je kunt dit omzeilen door zelf alle benodigde pakketten te installeren en te spelen met de opstartparameters).
Alle voorbereidende stappen zijn afgerond en we kunnen beginnen met de training. Vanuit de projectroot:
$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .Na het invoeren van de opdracht wordt automatisch een Conda-omgeving aangemaakt en start de training.
In het bovenstaande voorbeeld heb ik het aantal tijdperken doorgegeven voor training, de categorieën waarin we willen segmenteren (je kunt de volledige lijst bekijken ) en het adres van onze externe server.
Een volledige lijst met mogelijke parameters is te vinden in het MLproject-bestand.
5. Evalueer leerresultaten
Na het voltooien van de training kunnen we in de browser naar het adres van onze server gaan
Hier zien we een lijst met alle experimenten (linksboven), evenals informatie over runs (midden). We kunnen voor elke lancering meer gedetailleerde informatie (parameters, statistieken, artefacten en wat aanvullende informatie) bekijken.
Voor elke metriek kunnen we de geschiedenis van veranderingen observeren
Die. Op dit moment kunnen we de resultaten ‘handmatig’ analyseren en kun je ook automatische validatie instellen met behulp van de MLflow API.
6. Registreer het model
Nadat we ons model hebben geanalyseerd en besloten dat het klaar is voor de strijd, gaan we verder met het registreren ervan, hiervoor selecteren we de lancering die we nodig hebben (zoals weergegeven in de vorige paragraaf) en gaan we naar beneden.
Nadat we ons model een naam hebben gegeven, heeft het een versie. Als u een ander model met dezelfde naam opslaat, wordt de versie automatisch geüpgraded.
Voor elk model kunnen we een beschrijving toevoegen en een van de drie statussen selecteren (Staging, Productie, Gearchiveerd); vervolgens hebben we met behulp van de API toegang tot deze statussen, wat, samen met versiebeheer, extra flexibiliteit biedt.
Ook hebben wij eenvoudig toegang tot alle modellen
en hun versies
Net als in de vorige paragraaf kunnen alle bewerkingen worden uitgevoerd met behulp van de API.
7. Implementeer het model
In dit stadium hebben we al een getraind (keras) model. Een voorbeeld van hoe je het kunt gebruiken:
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 resultHier is self.registry voor het gemak weer een kleine verpakking over mlflow.tracking.MlflowClient. Het punt is dat ik toegang krijg tot een externe server en daar naar een model zoek met de opgegeven naam en de nieuwste productieversie. Vervolgens download ik het artefact lokaal naar de map ./model en bouw ik het model vanuit deze map mlflow.keras.load_model(local_path). Nu kunnen we ons model gebruiken. CV (ML)-ontwikkelaars kunnen het model eenvoudig verbeteren en nieuwe versies publiceren.
Concluderend
Ik presenteerde een systeem dat het volgende mogelijk maakt:
- centraal informatie opslaan over ML-modellen, trainingsvoortgang en resultaten;
- snel een ontwikkelomgeving implementeren;
- de voortgang van het werken aan modellen monitoren en analyseren;
- het is handig om de status van modellen te bewerken en te beheren;
- De resulterende modellen zijn eenvoudig in te zetten.
Dit voorbeeld is speelgoed en dient als uitgangspunt voor het bouwen van uw eigen systeem, inclusief automatisering van de evaluatie van resultaten en registratie van modellen (respectievelijk punt 5 en 6), of u voegt versiebeheer van datasets toe, of misschien iets anders? Het punt dat ik probeerde te maken is dat je MLOps als geheel nodig hebt, MLflow is slechts een middel om een doel te bereiken.
Schrijf op welke problemen u bent tegengekomen en die ik niet heb weergegeven?
Wat zou u aan het systeem toevoegen om het aan uw behoeften te laten voldoen?
Welke hulpmiddelen en benaderingen gebruikt u om alle of een deel van de problemen op te lossen?
PS Ik laat een paar links achter:
github-project -
MLflow -
Mijn werkmail voor vragen - [e-mail beveiligd]
Ons bedrijf organiseert periodiek verschillende evenementen voor IT-specialisten, bijvoorbeeld: op 8 juli om 19 uur Moskou-tijd is er een CV-meetup in online-formaat, als u geïnteresseerd bent, kunt u deelnemen, registratie .
Bron: www.habr.com