![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-laribi.jpeg\")
![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/04\/Medium-Blog.png\" "\\"Medium")
<\/span><\/div>Deel 1 - Hoe implementeert u Mlflow tracking instance op Kubernetes?<\/h1><\/div>Inleiding<\/h2><\/div>Mlflow is een veelgebruikt hulpmiddel in de data wetenschap\/ML-gemeenschap om experimenten bij te houden en modellen voor machinaal leren in verschillende stadia te beheren. Met behulp hiervan kunnen we metriek, modellen en artefacten opslaan om de prestaties van modellen gemakkelijk te vergelijken en hun levenscycli te beheren. Daarnaast biedt Mlflow een module om modellen als API-eindpunt aan te bieden, wat de integratie met elk product of webapp vergemakkelijkt.<\/p>\n<\/div>
Dat gezegd hebbende, het gebruik van machine learning in online producten is cool, maar afhankelijk van de grootte van het model, de aard (ML, deep learning, ... ) en de belasting (aanvragen van gebruikers) kan het een uitdaging zijn om de benodigde bronnen te dimensioneren en een redelijke responstijd te garanderen. Daarom is het gebruik van een schaalbare infrastructuur zoals Kubernetes-clusters essentieel om de beschikbaarheid en prestaties van de service in de inferentiefase te handhaven.<\/p>\n
In deze context publiceren we een serie van drie artikelen waarin we de volgende vragen beantwoorden:<\/p>\n<\/div>
- <\/i><\/span>Hoe Mlflow tracking instance op Kubernetes implementeren en gebruiken?<\/div><\/li>
- <\/i><\/span>Hoe Machine Learning-modellen als API te serveren met behulp van Mlflow?<\/div><\/li>
- <\/i><\/span>Hoe kunnen we een groot aantal verzoeken verwerken en onze inferentietaak schaalbaar maken voor ge\u00efndustrialiseerde producten?<\/div><\/li><\/ul>
Laten we dit eerste artikel dus beginnen met een introductie van Kubernetes en de componenten ervan, en de implementatie van een volginstantie naar logboekmodellen doorlopen.<\/p>\n<\/div>
Overzicht op Kubernetes<\/h2><\/div>Kubernetes is een open-source project dat in 2014 door Google werd uitgebracht. Het is een containerbesturings- en orkestratiesysteem waarmee applicaties automatisch kunnen worden ingezet, geschaald en gepland. Het heeft de volgende architectuur:<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27705%27%20height%3D%270%27%20viewBox%3D%270%200%20705%200%27%3E%3Crect%20width%3D%27705%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Master<\/strong>: Het handelt invoerconfiguraties af, plant gecontaineriseerde apps op de verschillende nodes en bewaakt hun status. De master bestaat uit:<\/p>\n<\/div>- <\/i><\/span>API-server:\u00a0<\/strong>maakt de interactie met het cluster mogelijk en valideert de commando's die door de ontwikkelaar worden verzonden om het cluster of de app-status bij te werken.<\/div><\/li>
- <\/i><\/span>Scheduler<\/strong>: beslist\u00a0<\/strong>op welke knooppunten nieuwe objecten uitgevoerd moeten worden om stabiliteit en load balancing te garanderen.<\/div><\/li>
- <\/i><\/span>Etcd:<\/strong>\u00a0een sleutel-waarde database die de verschillende bronconfiguraties en -toestanden opslaat<\/div><\/li>
- <\/i><\/span>Controller Manager:<\/strong>bewaakt de clustertoestand en de verschillende bronnen en zorgt ervoor dat de huidige toestand overeenkomt met de gewenste toestand.<\/div><\/li><\/ul>
Knooppunten:<\/strong> Dit zijn de uitvoerende knooppunten waarin de ingezette containers leven. Hun belangrijkste onderdelen zijn:<\/p>\n<\/div>- <\/i><\/span>Peulen:\u00a0<\/strong>zijn de fundamentele uitvoeringseenheden in Kubernetes. Een Pod kapselt een toepassing in als een enkele container of meerdere containers die samenwerken met gedeelde opslagvolumes en netwerken.<\/div><\/li>
- <\/i><\/span>\n
Kubelet:<\/strong>is\u00a0<\/strong>een\u00a0<\/strong>agent voor het inspecteren van de containerstatus en het communiceren met de Kubernetes-master.<\/p>\n<\/div><\/li><\/ul>Het is de keuze bij uitstek wanneer een applicatie meerdere services heeft die met elkaar communiceren, omdat het ervoor zorgt dat elke service zijn eigen gecontaineriseerde omgeving heeft met een set regels om met anderen te communiceren. Daarnaast biedt het de interessante mogelijkheid om een applicatie op te schalen zonder dat u zich zorgen hoeft te maken over het beheren of synchroniseren van nieuwe services en om resources tussen verschillende machines in balans te brengen.<\/p>\n
Op hoog niveau zullen wij, als data wetenschappers of ML-ingenieurs, communiceren met Kubernetes via de server-API met behulp van CLI-commando's of YAML-configuratiebestanden om apps te implementeren en bloot te stellen, of om onze resources-status op te vragen.<\/p>\n<\/div>
Praktische vereisten<\/h2><\/div>Voor deze hands-on zullen we GCP gebruiken als een cloud provider. Eerst moeten we :<\/p>\n<\/div>
1. Cre\u00eber de infrastructurele elementen<\/h3><\/div>- <\/i><\/span>mlflow_gke:<\/strong> een emmer voor het opslaan van bestanden, datasets...<\/div><\/li>
- <\/i><\/span>\n
mlflow-k8s<\/strong>: een GKE-cluster met drie knooppunten (e2-highcpu-4) om zowel de trackingmodule als het machine-learningmodel in te zetten.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
belastingstesten:\u00a0<\/strong>een GKE-cluster met drie knooppunten (e2-standaard-2) om belastingstests uit te voeren. Deze zal worden gebruikt in het derde artikel van deze serie.<\/p>\n<\/div><\/li><\/ul>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27659%27%20height%3D%270%27%20viewBox%3D%270%200%20659%200%27%3E%3Crect%20width%3D%27659%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
2. Configureer het lokale werkstation<\/h3><\/div>- <\/i><\/span>\n
Installeer python vereisten voor interactie met GCP en mlflow cli<\/p>\n
pip installeer mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Heb\u00a0gcloud<\/a>\u00a0en\u00a0kubectl<\/a>\u00a0geconfigureerd met de referenties om toegang te krijgen tot het GCP project en de clusters<\/div><\/li>
- <\/i><\/span>Zorg dat de Helm CLI ge\u00efnstalleerd en ge\u00efnitialiseerd is. Gelieve\u00a0vind hier de instructies<\/a>\u00a0voor het geval u de client nog niet hebt.<\/div><\/li><\/ul>
3. Kloon de hands-on projectrepository om de code te krijgen<\/h3><\/div>git kloon https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>Uitrol van Mlflow Tracking instantie<\/h2><\/div>1. De clusteromgeving instellen<\/h3><\/div>- <\/i><\/span>Maak een serviceaccount om de interactie met GCS mogelijk te maken
\n<\/strong>Dit kan gedaan worden via de google cloud console, onder de\u00a0iam sectie<\/a>. We moeten een serviceaccount aanmaken met beheerdersrechten voor opslagobjecten, een verificatiesleutel genereren en deze downloaden als keyfile.json<\/div><\/li>- <\/i><\/span>Koppel het authenticatiebestand aan als een geheim<\/strong>
\n<\/strong>Met geheimen kunnen we de referenties op een veilige manier behandelen, zodat ze alleen zichtbaar zijn voor relevante bronnen.\u00a0<\/strong>Hiervoor maken we een geheim volume aan en stellen we het authenticatiebestand alleen aan de benodigde containers bloot.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27634%27%20height%3D%270%27%20viewBox%3D%270%200%20634%200%27%3E%3Crect%20width%3D%27634%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
2. De uitrol van de server volgen<\/h3><\/div>- <\/i><\/span>Postgres opslag<\/strong>
\n<\/strong>Postgre dient als backend opslagelement voor mlflow om modellen metadata en metriek op te slaan.
\nOm het te implementeren zullen we Helm gebruiken: een resourcemanager voor Kubernetes waar veel applicaties beschikbaar zijn in de vorm van grafieken of sjablonen die met eenvoudige commando's geconfigureerd kunnen worden.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo toevoegen bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Voorbeeld traceren<\/strong>
\n<\/strong>We zullen ook Helm charts gebruiken om de tracking server te implementeren, maar eerst moeten we een docker image bouwen met de versie die we willen, zodat deze gedownload en ge\u00efmplementeerd kan worden door Helm. Merk op dat voor Postgres het image al op een openbare repository stond, maar hier zullen we ons eigen image maken.<\/p>\ncd mlflow-serving-voorbeeld<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Zodra het image naar het image-register is gepushed, kunnen we het via helm op het cluster implementeren met behulp van de onderstaande commando's.<\/p>\n
roer repo toevoegen mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>roer mlf-ts mlflow-tracking\/mlflow-tracking-server installeren\n--set env.mlflowArtifactPath=$\n-set env.mlflowDBAddr=mlf-db-postgresql\n-set env.mlflowUser=postgres\n-set env.mlflowPass=mlflow\n-set env.mlflowDBName=mlflow_db\n-set env.mlflowDBPort=5432\n-set service.type=LoadBalancer\n-set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nNu zou Mlflow moeten werken en de UI zou toegankelijk moeten zijn via het loadbalancer IP. We kunnen het toegewezen IP controleren met\u00a0k<\/em>ubectl get diensten<\/em>.<\/em><\/strong>A<\/em>Ook kunnen we de implementatie debuggen door toegang te krijgen tot de logboeken\u00a0via\u00a0<\/em>kubectl pods beschrijven<\/strong>.<\/em>
Tot nu toe ziet onze huidige architectuur er als volgt uit:<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27621%27%20height%3D%270%27%20viewBox%3D%270%200%20621%200%27%3E%3Crect%20width%3D%27621%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Houd er rekening mee dat loadbalancers toegankelijk zijn voor iedereen op het internet, dus het is essentieel om na te denken over het beveiligen van onze volginstantie door een authenticatielaag toe te voegen. Dit kan gedaan worden met de\u00a0identiteitsbewuste proxy<\/a>\u00a0op GCP, maar wordt niet behandeld in dit artikel.<\/p>\n<\/div>3. Basismodel maken<\/h3><\/div>Nu onze infrastructuur en Mlflow-instantie klaar zijn, kunnen we proberen om een eenvoudig ML-model uit te voeren en dit in het modelregister op te slaan voor later gebruik.
\nWe zullen de dataset voor wijnkwaliteit gebruiken, die bestaat uit ongeveer 4900 monsters en 11 kenmerken die wijnkenmerken weergeven. Het label loopt van 3 tot 9 en kan worden gezien als een beoordeling.
\nDit is een klassiek voorbeeld, waarin we een Xgboost regressiemodel trainen en samen met de parameters en metriek opslaan. De volledige code vindt u in deze\u00a0notebook<\/a>.
\nU hebt misschien gemerkt dat de integratie met Mlflow eenvoudig is en kan worden samengevat in het onderstaande codefragment dat het volgende aanroept\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() en mlflow.xgboost.log_model()<\/strong><\/em>om respectievelijk een nieuw experiment aan te maken, de trainingsparameters, de evaluatiemetriek en het getrainde model zelf op te slaan.<\/p>\n<\/div>met mlflow.start_run() als run:\n \n # mlflow-sessie starten\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"estimators\", estimators)\n\n # Model maken en aanpassen\n model = xgb.XGBRegressor(\n max_depth=max_depth,\n min_child_weight=min_child_weight,\n n_estimators=estimators\n random_state=42)\n model.fit(X_train, y_train)\n\n # MLflow metriek\n voorspellingen = model.predict(X_test)\n rmse = np.sqrt(gemiddelde_kwadraatfout(y_test, voorspellingen))\n mlflow.log_metric(\"rmse\", rmse)\n\n # Log model\n mlflow.xgboost.log_model(model, \"xgboost-model\", geregistreerd_model_naam = model_naam)\nDoor het meegeleverde notitieboek uit te voeren, wordt er een nieuwe rij toegevoegd aan de tracking instance interface die overeenkomt met het nieuwe experiment.<\/p>\n<\/div>![\"Image\"](\"data:image\/svg+xml,%3Csvg%20xmlns%3D%27http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%27%20width%3D%27642%27%20height%3D%270%27%20viewBox%3D%270%200%20642%200%27%3E%3Crect%20width%3D%27642%27%20height%3D%270%27%20fill-opacity%3D%220%22%2F%3E%3C%2Fsvg%3E\")
Als we ten slotte tevreden zijn met de prestaties van het model, kunnen we het laden vanuit de volginstantie en gebruiken voor inferentie in python. Dit kan ook gedaan worden met het eerder gedeelde notebook. Merk op dat we in dit voorbeeld het model hebben geladen met behulp van de run-ID, maar vergeet niet dat Mlflow ook andere interessante manieren biedt om modellen te identificeren aan de hand van tags, versies of stadia. Raadpleeg voor meer details de documentatie over het modelregister\u00a0hier<\/a>.<\/p>\n<\/div>Conclusie<\/h2><\/div>In dit artikel zijn we erin geslaagd om Mlflow tracking instance te implementeren om onze data wetenschapsexperimenten af te handelen en hebben we een snel voorbeeld gegeven om te laten zien hoe we een model kunnen loggen en opslaan voor toekomstige inferentie op python. In het volgende artikel van deze serie zullen we leren hoe we dit model als API kunnen aanbieden. Dit is van groot belang omdat het de interactie met het model en de integratie ervan in een product of applicatie vergemakkelijkt. Bovendien zorgt Kubernetes ervoor dat het gemakkelijk schaalbaar blijft en verschillende belastingsniveaus aankan.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
Inleiding<\/h2><\/div>Mlflow is een veelgebruikt hulpmiddel in de data wetenschap\/ML-gemeenschap om experimenten bij te houden en modellen voor machinaal leren in verschillende stadia te beheren. Met behulp hiervan kunnen we metriek, modellen en artefacten opslaan om de prestaties van modellen gemakkelijk te vergelijken en hun levenscycli te beheren. Daarnaast biedt Mlflow een module om modellen als API-eindpunt aan te bieden, wat de integratie met elk product of webapp vergemakkelijkt.<\/p>\n<\/div>
Dat gezegd hebbende, het gebruik van machine learning in online producten is cool, maar afhankelijk van de grootte van het model, de aard (ML, deep learning, ... ) en de belasting (aanvragen van gebruikers) kan het een uitdaging zijn om de benodigde bronnen te dimensioneren en een redelijke responstijd te garanderen. Daarom is het gebruik van een schaalbare infrastructuur zoals Kubernetes-clusters essentieel om de beschikbaarheid en prestaties van de service in de inferentiefase te handhaven.<\/p>\n
In deze context publiceren we een serie van drie artikelen waarin we de volgende vragen beantwoorden:<\/p>\n<\/div>
- <\/i><\/span>Hoe Mlflow tracking instance op Kubernetes implementeren en gebruiken?<\/div><\/li>
- <\/i><\/span>Hoe Machine Learning-modellen als API te serveren met behulp van Mlflow?<\/div><\/li>
- <\/i><\/span>Hoe kunnen we een groot aantal verzoeken verwerken en onze inferentietaak schaalbaar maken voor ge\u00efndustrialiseerde producten?<\/div><\/li><\/ul>
Laten we dit eerste artikel dus beginnen met een introductie van Kubernetes en de componenten ervan, en de implementatie van een volginstantie naar logboekmodellen doorlopen.<\/p>\n<\/div>
Overzicht op Kubernetes<\/h2><\/div>Kubernetes is een open-source project dat in 2014 door Google werd uitgebracht. Het is een containerbesturings- en orkestratiesysteem waarmee applicaties automatisch kunnen worden ingezet, geschaald en gepland. Het heeft de volgende architectuur:<\/p>\n<\/div>
Master<\/strong>: Het handelt invoerconfiguraties af, plant gecontaineriseerde apps op de verschillende nodes en bewaakt hun status. De master bestaat uit:<\/p>\n<\/div>- <\/i><\/span>API-server:\u00a0<\/strong>maakt de interactie met het cluster mogelijk en valideert de commando's die door de ontwikkelaar worden verzonden om het cluster of de app-status bij te werken.<\/div><\/li>
- <\/i><\/span>Scheduler<\/strong>: beslist\u00a0<\/strong>op welke knooppunten nieuwe objecten uitgevoerd moeten worden om stabiliteit en load balancing te garanderen.<\/div><\/li>
- <\/i><\/span>Etcd:<\/strong>\u00a0een sleutel-waarde database die de verschillende bronconfiguraties en -toestanden opslaat<\/div><\/li>
- <\/i><\/span>Controller Manager:<\/strong>bewaakt de clustertoestand en de verschillende bronnen en zorgt ervoor dat de huidige toestand overeenkomt met de gewenste toestand.<\/div><\/li><\/ul>
Knooppunten:<\/strong> Dit zijn de uitvoerende knooppunten waarin de ingezette containers leven. Hun belangrijkste onderdelen zijn:<\/p>\n<\/div>- <\/i><\/span>Peulen:\u00a0<\/strong>zijn de fundamentele uitvoeringseenheden in Kubernetes. Een Pod kapselt een toepassing in als een enkele container of meerdere containers die samenwerken met gedeelde opslagvolumes en netwerken.<\/div><\/li>
- <\/i><\/span>\n
Kubelet:<\/strong>is\u00a0<\/strong>een\u00a0<\/strong>agent voor het inspecteren van de containerstatus en het communiceren met de Kubernetes-master.<\/p>\n<\/div><\/li><\/ul>Het is de keuze bij uitstek wanneer een applicatie meerdere services heeft die met elkaar communiceren, omdat het ervoor zorgt dat elke service zijn eigen gecontaineriseerde omgeving heeft met een set regels om met anderen te communiceren. Daarnaast biedt het de interessante mogelijkheid om een applicatie op te schalen zonder dat u zich zorgen hoeft te maken over het beheren of synchroniseren van nieuwe services en om resources tussen verschillende machines in balans te brengen.<\/p>\n
Op hoog niveau zullen wij, als data wetenschappers of ML-ingenieurs, communiceren met Kubernetes via de server-API met behulp van CLI-commando's of YAML-configuratiebestanden om apps te implementeren en bloot te stellen, of om onze resources-status op te vragen.<\/p>\n<\/div>
Praktische vereisten<\/h2><\/div>Voor deze hands-on zullen we GCP gebruiken als een cloud provider. Eerst moeten we :<\/p>\n<\/div>
1. Cre\u00eber de infrastructurele elementen<\/h3><\/div>- <\/i><\/span>mlflow_gke:<\/strong> een emmer voor het opslaan van bestanden, datasets...<\/div><\/li>
- <\/i><\/span>\n
mlflow-k8s<\/strong>: een GKE-cluster met drie knooppunten (e2-highcpu-4) om zowel de trackingmodule als het machine-learningmodel in te zetten.<\/p>\n<\/div><\/li>- <\/i><\/span>\n
belastingstesten:\u00a0<\/strong>een GKE-cluster met drie knooppunten (e2-standaard-2) om belastingstests uit te voeren. Deze zal worden gebruikt in het derde artikel van deze serie.<\/p>\n<\/div><\/li><\/ul>2. Configureer het lokale werkstation<\/h3><\/div>- <\/i><\/span>\n
Installeer python vereisten voor interactie met GCP en mlflow cli<\/p>\n
pip installeer mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Heb\u00a0gcloud<\/a>\u00a0en\u00a0kubectl<\/a>\u00a0geconfigureerd met de referenties om toegang te krijgen tot het GCP project en de clusters<\/div><\/li>
- <\/i><\/span>Zorg dat de Helm CLI ge\u00efnstalleerd en ge\u00efnitialiseerd is. Gelieve\u00a0vind hier de instructies<\/a>\u00a0voor het geval u de client nog niet hebt.<\/div><\/li><\/ul>
3. Kloon de hands-on projectrepository om de code te krijgen<\/h3><\/div>git kloon https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>Uitrol van Mlflow Tracking instantie<\/h2><\/div>1. De clusteromgeving instellen<\/h3><\/div>- <\/i><\/span>Maak een serviceaccount om de interactie met GCS mogelijk te maken
\n<\/strong>Dit kan gedaan worden via de google cloud console, onder de\u00a0iam sectie<\/a>. We moeten een serviceaccount aanmaken met beheerdersrechten voor opslagobjecten, een verificatiesleutel genereren en deze downloaden als keyfile.json<\/div><\/li>- <\/i><\/span>Koppel het authenticatiebestand aan als een geheim<\/strong>
\n<\/strong>Met geheimen kunnen we de referenties op een veilige manier behandelen, zodat ze alleen zichtbaar zijn voor relevante bronnen.\u00a0<\/strong>Hiervoor maken we een geheim volume aan en stellen we het authenticatiebestand alleen aan de benodigde containers bloot.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>2. De uitrol van de server volgen<\/h3><\/div>- <\/i><\/span>Postgres opslag<\/strong>
\n<\/strong>Postgre dient als backend opslagelement voor mlflow om modellen metadata en metriek op te slaan.
\nOm het te implementeren zullen we Helm gebruiken: een resourcemanager voor Kubernetes waar veel applicaties beschikbaar zijn in de vorm van grafieken of sjablonen die met eenvoudige commando's geconfigureerd kunnen worden.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo toevoegen bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>Voorbeeld traceren<\/strong>
\n<\/strong>We zullen ook Helm charts gebruiken om de tracking server te implementeren, maar eerst moeten we een docker image bouwen met de versie die we willen, zodat deze gedownload en ge\u00efmplementeerd kan worden door Helm. Merk op dat voor Postgres het image al op een openbare repository stond, maar hier zullen we ons eigen image maken.<\/p>\ncd mlflow-serving-voorbeeld<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Zodra het image naar het image-register is gepushed, kunnen we het via helm op het cluster implementeren met behulp van de onderstaande commando's.<\/p>\n
roer repo toevoegen mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>roer mlf-ts mlflow-tracking\/mlflow-tracking-server installeren\n--set env.mlflowArtifactPath=$\n-set env.mlflowDBAddr=mlf-db-postgresql\n-set env.mlflowUser=postgres\n-set env.mlflowPass=mlflow\n-set env.mlflowDBName=mlflow_db\n-set env.mlflowDBPort=5432\n-set service.type=LoadBalancer\n-set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nNu zou Mlflow moeten werken en de UI zou toegankelijk moeten zijn via het loadbalancer IP. We kunnen het toegewezen IP controleren met\u00a0k<\/em>ubectl get diensten<\/em>.<\/em><\/strong>A<\/em>Ook kunnen we de implementatie debuggen door toegang te krijgen tot de logboeken\u00a0via\u00a0<\/em>kubectl pods beschrijven<\/strong>.<\/em>
Tot nu toe ziet onze huidige architectuur er als volgt uit:<\/p>\n<\/div>Houd er rekening mee dat loadbalancers toegankelijk zijn voor iedereen op het internet, dus het is essentieel om na te denken over het beveiligen van onze volginstantie door een authenticatielaag toe te voegen. Dit kan gedaan worden met de\u00a0identiteitsbewuste proxy<\/a>\u00a0op GCP, maar wordt niet behandeld in dit artikel.<\/p>\n<\/div>3. Basismodel maken<\/h3><\/div>Nu onze infrastructuur en Mlflow-instantie klaar zijn, kunnen we proberen om een eenvoudig ML-model uit te voeren en dit in het modelregister op te slaan voor later gebruik.
\nWe zullen de dataset voor wijnkwaliteit gebruiken, die bestaat uit ongeveer 4900 monsters en 11 kenmerken die wijnkenmerken weergeven. Het label loopt van 3 tot 9 en kan worden gezien als een beoordeling.
\nDit is een klassiek voorbeeld, waarin we een Xgboost regressiemodel trainen en samen met de parameters en metriek opslaan. De volledige code vindt u in deze\u00a0notebook<\/a>.
\nU hebt misschien gemerkt dat de integratie met Mlflow eenvoudig is en kan worden samengevat in het onderstaande codefragment dat het volgende aanroept\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() en mlflow.xgboost.log_model()<\/strong><\/em>om respectievelijk een nieuw experiment aan te maken, de trainingsparameters, de evaluatiemetriek en het getrainde model zelf op te slaan.<\/p>\n<\/div>met mlflow.start_run() als run:\n \n # mlflow-sessie starten\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"estimators\", estimators)\n\n # Model maken en aanpassen\n model = xgb.XGBRegressor(\n max_depth=max_depth,\n min_child_weight=min_child_weight,\n n_estimators=estimators\n random_state=42)\n model.fit(X_train, y_train)\n\n # MLflow metriek\n voorspellingen = model.predict(X_test)\n rmse = np.sqrt(gemiddelde_kwadraatfout(y_test, voorspellingen))\n mlflow.log_metric(\"rmse\", rmse)\n\n # Log model\n mlflow.xgboost.log_model(model, \"xgboost-model\", geregistreerd_model_naam = model_naam)\nDoor het meegeleverde notitieboek uit te voeren, wordt er een nieuwe rij toegevoegd aan de tracking instance interface die overeenkomt met het nieuwe experiment.<\/p>\n<\/div>
Als we ten slotte tevreden zijn met de prestaties van het model, kunnen we het laden vanuit de volginstantie en gebruiken voor inferentie in python. Dit kan ook gedaan worden met het eerder gedeelde notebook. Merk op dat we in dit voorbeeld het model hebben geladen met behulp van de run-ID, maar vergeet niet dat Mlflow ook andere interessante manieren biedt om modellen te identificeren aan de hand van tags, versies of stadia. Raadpleeg voor meer details de documentatie over het modelregister\u00a0hier<\/a>.<\/p>\n<\/div>Conclusie<\/h2><\/div>In dit artikel zijn we erin geslaagd om Mlflow tracking instance te implementeren om onze data wetenschapsexperimenten af te handelen en hebben we een snel voorbeeld gegeven om te laten zien hoe we een model kunnen loggen en opslaan voor toekomstige inferentie op python. In het volgende artikel van deze serie zullen we leren hoe we dit model als API kunnen aanbieden. Dit is van groot belang omdat het de interactie met het model en de integratie ervan in een product of applicatie vergemakkelijkt. Bovendien zorgt Kubernetes ervoor dat het gemakkelijk schaalbaar blijft en verschillende belastingsniveaus aankan.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
Mlflow is een veelgebruikt hulpmiddel in de data wetenschap\/ML-gemeenschap om experimenten bij te houden en modellen voor machinaal leren in verschillende stadia te beheren. Met behulp hiervan kunnen we metriek, modellen en artefacten opslaan om de prestaties van modellen gemakkelijk te vergelijken en hun levenscycli te beheren. Daarnaast biedt Mlflow een module om modellen als API-eindpunt aan te bieden, wat de integratie met elk product of webapp vergemakkelijkt.<\/p>\n<\/div>
Dat gezegd hebbende, het gebruik van machine learning in online producten is cool, maar afhankelijk van de grootte van het model, de aard (ML, deep learning, ... ) en de belasting (aanvragen van gebruikers) kan het een uitdaging zijn om de benodigde bronnen te dimensioneren en een redelijke responstijd te garanderen. Daarom is het gebruik van een schaalbare infrastructuur zoals Kubernetes-clusters essentieel om de beschikbaarheid en prestaties van de service in de inferentiefase te handhaven.<\/p>\n
In deze context publiceren we een serie van drie artikelen waarin we de volgende vragen beantwoorden:<\/p>\n<\/div>
- <\/i><\/span>Hoe Mlflow tracking instance op Kubernetes implementeren en gebruiken?<\/div><\/li>
- <\/i><\/span>
Hoe Machine Learning-modellen als API te serveren met behulp van Mlflow?<\/div><\/li>- <\/i><\/span>
Hoe kunnen we een groot aantal verzoeken verwerken en onze inferentietaak schaalbaar maken voor ge\u00efndustrialiseerde producten?<\/div><\/li><\/ul>Laten we dit eerste artikel dus beginnen met een introductie van Kubernetes en de componenten ervan, en de implementatie van een volginstantie naar logboekmodellen doorlopen.<\/p>\n<\/div>
Overzicht op Kubernetes<\/h2><\/div>
Kubernetes is een open-source project dat in 2014 door Google werd uitgebracht. Het is een containerbesturings- en orkestratiesysteem waarmee applicaties automatisch kunnen worden ingezet, geschaald en gepland. Het heeft de volgende architectuur:<\/p>\n<\/div>
Master<\/strong>: Het handelt invoerconfiguraties af, plant gecontaineriseerde apps op de verschillende nodes en bewaakt hun status. De master bestaat uit:<\/p>\n<\/div>
- <\/i><\/span>API-server:\u00a0<\/strong>maakt de interactie met het cluster mogelijk en valideert de commando's die door de ontwikkelaar worden verzonden om het cluster of de app-status bij te werken.<\/div><\/li>
- <\/i><\/span>
Scheduler<\/strong>: beslist\u00a0<\/strong>op welke knooppunten nieuwe objecten uitgevoerd moeten worden om stabiliteit en load balancing te garanderen.<\/div><\/li>- <\/i><\/span>
Etcd:<\/strong>\u00a0een sleutel-waarde database die de verschillende bronconfiguraties en -toestanden opslaat<\/div><\/li>- <\/i><\/span>
Controller Manager:<\/strong>bewaakt de clustertoestand en de verschillende bronnen en zorgt ervoor dat de huidige toestand overeenkomt met de gewenste toestand.<\/div><\/li><\/ul>Knooppunten:<\/strong> Dit zijn de uitvoerende knooppunten waarin de ingezette containers leven. Hun belangrijkste onderdelen zijn:<\/p>\n<\/div>
- <\/i><\/span>Peulen:\u00a0<\/strong>zijn de fundamentele uitvoeringseenheden in Kubernetes. Een Pod kapselt een toepassing in als een enkele container of meerdere containers die samenwerken met gedeelde opslagvolumes en netwerken.<\/div><\/li>
- <\/i><\/span>
\nKubelet:<\/strong>is\u00a0<\/strong>een\u00a0<\/strong>agent voor het inspecteren van de containerstatus en het communiceren met de Kubernetes-master.<\/p>\n<\/div><\/li><\/ul>
Het is de keuze bij uitstek wanneer een applicatie meerdere services heeft die met elkaar communiceren, omdat het ervoor zorgt dat elke service zijn eigen gecontaineriseerde omgeving heeft met een set regels om met anderen te communiceren. Daarnaast biedt het de interessante mogelijkheid om een applicatie op te schalen zonder dat u zich zorgen hoeft te maken over het beheren of synchroniseren van nieuwe services en om resources tussen verschillende machines in balans te brengen.<\/p>\n
Op hoog niveau zullen wij, als data wetenschappers of ML-ingenieurs, communiceren met Kubernetes via de server-API met behulp van CLI-commando's of YAML-configuratiebestanden om apps te implementeren en bloot te stellen, of om onze resources-status op te vragen.<\/p>\n<\/div>
Praktische vereisten<\/h2><\/div>
Voor deze hands-on zullen we GCP gebruiken als een cloud provider. Eerst moeten we :<\/p>\n<\/div>
1. Cre\u00eber de infrastructurele elementen<\/h3><\/div>
- <\/i><\/span>mlflow_gke:<\/strong> een emmer voor het opslaan van bestanden, datasets...<\/div><\/li>
- <\/i><\/span>
\nmlflow-k8s<\/strong>: een GKE-cluster met drie knooppunten (e2-highcpu-4) om zowel de trackingmodule als het machine-learningmodel in te zetten.<\/p>\n<\/div><\/li>
- <\/i><\/span>
\nbelastingstesten:\u00a0<\/strong>een GKE-cluster met drie knooppunten (e2-standaard-2) om belastingstests uit te voeren. Deze zal worden gebruikt in het derde artikel van deze serie.<\/p>\n<\/div><\/li><\/ul>
2. Configureer het lokale werkstation<\/h3><\/div>
- <\/i><\/span>\n
Installeer python vereisten voor interactie met GCP en mlflow cli<\/p>\n
pip installeer mlflow gcsfs google-cloud google-cloud-storage kubernetes<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>
Heb\u00a0gcloud<\/a>\u00a0en\u00a0kubectl<\/a>\u00a0geconfigureerd met de referenties om toegang te krijgen tot het GCP project en de clusters<\/div><\/li>- <\/i><\/span>
Zorg dat de Helm CLI ge\u00efnstalleerd en ge\u00efnitialiseerd is. Gelieve\u00a0vind hier de instructies<\/a>\u00a0voor het geval u de client nog niet hebt.<\/div><\/li><\/ul>3. Kloon de hands-on projectrepository om de code te krijgen<\/h3><\/div>
git kloon https:\/\/github.com\/artefactory-global\/mlflow-serving-example<\/a><\/p>\n<\/div>
Uitrol van Mlflow Tracking instantie<\/h2><\/div>
1. De clusteromgeving instellen<\/h3><\/div>
- <\/i><\/span>Maak een serviceaccount om de interactie met GCS mogelijk te maken
\n<\/strong>Dit kan gedaan worden via de google cloud console, onder de\u00a0iam sectie<\/a>. We moeten een serviceaccount aanmaken met beheerdersrechten voor opslagobjecten, een verificatiesleutel genereren en deze downloaden als keyfile.json<\/div><\/li>- <\/i><\/span>
Koppel het authenticatiebestand aan als een geheim<\/strong>
\n<\/strong>Met geheimen kunnen we de referenties op een veilige manier behandelen, zodat ze alleen zichtbaar zijn voor relevante bronnen.\u00a0<\/strong>Hiervoor maken we een geheim volume aan en stellen we het authenticatiebestand alleen aan de benodigde containers bloot.
\nkubectl create secret generic gcsfs-creds -from-file=.\/keyfile.json<\/span><\/div><\/li><\/ul>2. De uitrol van de server volgen<\/h3><\/div>
- <\/i><\/span>Postgres opslag<\/strong>
\n<\/strong>Postgre dient als backend opslagelement voor mlflow om modellen metadata en metriek op te slaan.
\nOm het te implementeren zullen we Helm gebruiken: een resourcemanager voor Kubernetes waar veel applicaties beschikbaar zijn in de vorm van grafieken of sjablonen die met eenvoudige commando's geconfigureerd kunnen worden.<\/p>\n#docs: https:\/\/artifacthub.io\/packages\/helm\/bitnami\/postgresql<\/span>helm repo toevoegen bitnami https:\/\/charts.bitnami.com\/bitnami<\/span>helm install mlf-db bitnami\/postgresql --set postgresqlDatabase=mlflow_db --set postgresqlPassword=mlflow --set service.type=NodePort<\/span><\/pre>\n<\/div><\/li>- <\/i><\/span>
Voorbeeld traceren<\/strong>
\n<\/strong>We zullen ook Helm charts gebruiken om de tracking server te implementeren, maar eerst moeten we een docker image bouwen met de versie die we willen, zodat deze gedownload en ge\u00efmplementeerd kan worden door Helm. Merk op dat voor Postgres het image al op een openbare repository stond, maar hier zullen we ons eigen image maken.<\/p>\ncd mlflow-serving-voorbeeld<\/span>docker build --tag $\/mlflow-tracking-server:v1 --file dockerfile_mlflow_tracking .<\/span>docker push $\/mlflow-tracking-server:v1<\/span><\/pre>\n<\/div><\/li><\/ul>Zodra het image naar het image-register is gepushed, kunnen we het via helm op het cluster implementeren met behulp van de onderstaande commando's.<\/p>\n
roer repo toevoegen mlflow-tracking https:\/\/artefactory-global.github.io\/mlflow-tracking-server\/<\/a><\/span>roer mlf-ts mlflow-tracking\/mlflow-tracking-server installeren\n--set env.mlflowArtifactPath=$\n-set env.mlflowDBAddr=mlf-db-postgresql\n-set env.mlflowUser=postgres\n-set env.mlflowPass=mlflow\n-set env.mlflowDBName=mlflow_db\n-set env.mlflowDBPort=5432\n-set service.type=LoadBalancer\n-set image.repository=$\/mlflow-tracking-server\n--set image.tag=v1<\/span><\/pre>\nNu zou Mlflow moeten werken en de UI zou toegankelijk moeten zijn via het loadbalancer IP. We kunnen het toegewezen IP controleren met\u00a0k<\/em>ubectl get diensten<\/em>.<\/em><\/strong>A<\/em>Ook kunnen we de implementatie debuggen door toegang te krijgen tot de logboeken\u00a0via\u00a0<\/em>kubectl pods beschrijven<\/strong>.<\/em>
Tot nu toe ziet onze huidige architectuur er als volgt uit:<\/p>\n<\/div>Houd er rekening mee dat loadbalancers toegankelijk zijn voor iedereen op het internet, dus het is essentieel om na te denken over het beveiligen van onze volginstantie door een authenticatielaag toe te voegen. Dit kan gedaan worden met de\u00a0identiteitsbewuste proxy<\/a>\u00a0op GCP, maar wordt niet behandeld in dit artikel.<\/p>\n<\/div>
3. Basismodel maken<\/h3><\/div>
Nu onze infrastructuur en Mlflow-instantie klaar zijn, kunnen we proberen om een eenvoudig ML-model uit te voeren en dit in het modelregister op te slaan voor later gebruik.
\nWe zullen de dataset voor wijnkwaliteit gebruiken, die bestaat uit ongeveer 4900 monsters en 11 kenmerken die wijnkenmerken weergeven. Het label loopt van 3 tot 9 en kan worden gezien als een beoordeling.
\nDit is een klassiek voorbeeld, waarin we een Xgboost regressiemodel trainen en samen met de parameters en metriek opslaan. De volledige code vindt u in deze\u00a0notebook<\/a>.
\nU hebt misschien gemerkt dat de integratie met Mlflow eenvoudig is en kan worden samengevat in het onderstaande codefragment dat het volgende aanroept\u00a0mlflow.start_run(), mlflow.log_param(), mlflow.log_metric() en mlflow.xgboost.log_model()<\/strong><\/em>om respectievelijk een nieuw experiment aan te maken, de trainingsparameters, de evaluatiemetriek en het getrainde model zelf op te slaan.<\/p>\n<\/div>met mlflow.start_run() als run:\n \n # mlflow-sessie starten\n mlflow.log_param(\"max_depth\", max_depth)\n mlflow.log_param(\"min_child_weight\", min_child_weight)\n mlflow.log_param(\"estimators\", estimators)\n\n # Model maken en aanpassen\n model = xgb.XGBRegressor(\n max_depth=max_depth,\n min_child_weight=min_child_weight,\n n_estimators=estimators\n random_state=42)\n model.fit(X_train, y_train)\n\n # MLflow metriek\n voorspellingen = model.predict(X_test)\n rmse = np.sqrt(gemiddelde_kwadraatfout(y_test, voorspellingen))\n mlflow.log_metric(\"rmse\", rmse)\n\n # Log model\n mlflow.xgboost.log_model(model, \"xgboost-model\", geregistreerd_model_naam = model_naam)\nDoor het meegeleverde notitieboek uit te voeren, wordt er een nieuwe rij toegevoegd aan de tracking instance interface die overeenkomt met het nieuwe experiment.<\/p>\n<\/div>
Als we ten slotte tevreden zijn met de prestaties van het model, kunnen we het laden vanuit de volginstantie en gebruiken voor inferentie in python. Dit kan ook gedaan worden met het eerder gedeelde notebook. Merk op dat we in dit voorbeeld het model hebben geladen met behulp van de run-ID, maar vergeet niet dat Mlflow ook andere interessante manieren biedt om modellen te identificeren aan de hand van tags, versies of stadia. Raadpleeg voor meer details de documentatie over het modelregister\u00a0hier<\/a>.<\/p>\n<\/div>
Conclusie<\/h2><\/div>
In dit artikel zijn we erin geslaagd om Mlflow tracking instance te implementeren om onze data wetenschapsexperimenten af te handelen en hebben we een snel voorbeeld gegeven om te laten zien hoe we een model kunnen loggen en opslaan voor toekomstige inferentie op python. In het volgende artikel van deze serie zullen we leren hoe we dit model als API kunnen aanbieden. Dit is van groot belang omdat het de interactie met het model en de integratie ervan in een product of applicatie vergemakkelijkt. Bovendien zorgt Kubernetes ervoor dat het gemakkelijk schaalbaar blijft en verschillende belastingsniveaus aankan.<\/p>\n<\/div><\/div><\/div><\/div><\/article>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
- <\/i><\/span>
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-article2.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/kais-article3.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais-4.png\")
![\"Image\"](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/10\/article-kais5.png\")
![](\"https:\/\/www.artefact.com\/\/wp-content\/uploads\/2021\/03\/medium.png\" "\\"middelgrote\\"")
<\/span><\/div>