Utplassering av en maskinlæringsmodell til AWS Lambda (2024)

I denne opplæringen tar vi en titt på hvordan du distribuerer en maskinlæringsmodell (AWS Lambda, viaServerløse rammer, og utfør den ved å brukeVouly. Vi vil også lage en CI/CD-pipeline medGitHub -handlingerfor å automatisere distribusjonsprosessen og kjøre ende-til-ende-tester.

Innhold

Prosjektoppsett

Det kan være morsomt å leke med ML-modeller på din lokale maskin. Ikke desto mindre, på slu*tten av dagen, må du distribuere den et sted for å tjene formålet i produksjonen. Selv om det er en rekke forskjellige distribusjonsalternativer tilgjengelig, er AWS Lambda et godt valg for når du har pigg trafikk eller når den sjelden brukes. I tillegg gjør AWS Lambda det enkelt å utføre ML-operasjoner parallelt. Du ringer bare Lambda-funksjonen din med Boto3 fra koden din som trenger ML-funksjonalitet. Med det, la oss bygge en ML-tjeneste for å presteresentimentanalyse.

Begynn med å lage et nytt prosjekt:

$ mkdir ml_lambda&& cdml_lambda&&git init $ python3.11 -m Venv Venv $kildevenv/bin/activate(venv)$

Lage en ny.gitignorefil.Legg deretter innholdet fra Python. Gitignore mal funnether. Legg til.gitignoreå git og forplikte seg:

$ git add .gitignore $ git commit -m'Initial commit'

For det andre, legg tilPytorchogTransformatorertil enkrav.txtfil:

fakkel == 2.0.1Transformers == 4.31.0

Installer dem:

(venv)$ pip install -r krav.txt

For det tredje, lag en ny modul kaltsentiment_model.py:

fra Transformatorer import rørledningklasse Sentimentmodell: def __i det__(selv-): selv-._Sentiment_analyse = rørledning("Sentimentanalyse",modell="ProsusAI/finbert") def forutsi(selv-, tekst): komme tilbake selv-._sentimentanalyse(tekst)[0] ["merkelapp"]

Her brukte viFinbertforhåndsutdannetnaturlig språkbehandling(NLP) -modell, som er designet for å forutsi sentiment på økonomisk tekst.

Vil du teste det ut lokalt?Legg til følgende i bunnen av modulen:

hvis __Navn__ == "__hoved__": eksempeltekst = "Dow Jones Industrial Average (^dji) ble grønt." modell = Sentimentmodell() sentiment = modell.forutsi(tekst=eksempeltekst) skrive ut(sentiment)

Utfør deretter modulen.Prøv litt annen prøvetekst.Sørg for å fjernehvisblokkerer en gang gjort.

Til slu*tt, oppretter et nytt prosjekt på GitHub og oppdater Git -fjernkontrollen.

AWS Lambda Handler

AWS Lambdaer en serverløs beregningstjeneste der du kan kjøre koden din.I stedet for tradisjonelle distribusjonstilbud, der du "leier" plass på en server, betaler du bare for faktisk utførelsestid.Derfor er det et godt valg når du har lite trafikk eller pigger i trafikken fra tid til annen.

Å kjøre Python-kode på AWS Lambda er ganske enkelt. Du må spesifisere en behandlerfunksjon og peke Lambda til den. Her er hvordan den forventede signaturen må se ut for behandlerfunksjonen:

def håndtak(begivenhet, kontekst): ...

Opprett en ny modul kalthandler.py:

import hogstfra Sentiment_model import SentimentmodellLogger = hogst.getLogger()Logger.Setlevel(hogst.Info)modell = Sentimentmodell()def håndtak(begivenhet, kontekst): hvis begivenhet.få("kilde") == "Keep_lambda_warm": Logger.info("Ingen ML-arbeid å gjøre. Bare å holde seg varm...") komme tilbake "Holde Lambda varm" komme tilbake { "sentiment": modell.forutsi(tekst=begivenhet["tekst"]) }

Så hva skjer her?

Først utenforhåndtakfunksjon, konfigurerte vi loggeren og initialiserte modellen vår. Kode skrevet utenforhåndtakfunksjonen utføres kun under Lambdas kaldstarter. For kaldstarter må Lambda:

1. Finn plass på en EC2 -forekomst
2. Initialiser utførelsesmiljøet
3. Initialiser modulen

Kaldstart er nødvendig etter omplasseringer og når lambdaen ikke er i bruk på en stund. AWS har ikke avslørt nøyaktig hvor lang tid en Lambda vil holde seg varm. Likevel, hvis du søker på nettet, finner du tider mellom fem og femten minutter. Siden kaldstart av en Lambda tar noen sekunder, vil du ofte ønske å holde Lambdaen i en varm tilstand. Vi vil faktisk bruke en egen Lambda-funksjon for dette, som med jevne mellomrom vil pinge Lambdaen vår for å holde den varm. Siden du igjen betaler for utførelsestid, ønsker vi ikke å kjøre hele ML-modellen når vi bare prøver å holde den varm, så vi la til følgendehvisblokkere:

hvis begivenhet.få("kilde") == "KEEP_LAMBDA_WARM": Logger.info("Ingen ML-arbeid å gjøre. Bare å holde seg varm...") komme tilbake "Holde Lambda varm"

For å lære mer om kaldstart, se gjennomLambda-utførelsesmiljøerfra dokumentene.

Serverløse rammer

For å distribuere Lambda-funksjonen vår, bruker viServerløst rammeverk, som hjelper deg med å utvikle og distribuere serverløse applikasjoner med letthet.Det er enkelt å bruke til brukssaken vår.Vi må lage enserverless.ymlkonfigurasjonsfil som forteller Serverless Framework hvilke serverløse skyressurser som skal opprettes og hvordan de skal starte applikasjonen vår som kjører på dem. Rammenstøtter flere skyleverandører, somAws,Google Cloud, ogAzure, for å nevne noen.

Det anbefales på det sterkeste at du går gjennomDitt første serverløse rammeprosjektFør du fortsetter med denne, så har du litt kontekst om hvordan serverløse rammer fungerer.

Legg til en nyserverless.ymlKonfigurasjonsfil:

service: ML-modellrammeversjon: '3'bruktotenv: ekteforsørger: Navn: aws region: ${opt:region, 'eu-west-1'} scene: $ {opt: scene, 'utvikling'} logRetentionInDays: 90 ECR: Bilder: Appimage: sti: ./funksjoner: ml_modell: bilde: Navn: Appimage pause: 90 minnestørrelse: 4096 miljø: TORCH_HOME: /tmp/.ml_cache TRANSFORMERS_CACHE: /tmp/.ml_cache/huggingfacetilpasset: varme opp: MLModelWarmer: aktivert: ekte arrangementer: - rute: rate (4 minutter) Samtidig: ${env:WARMER_CONCURRENCY, 2} ordrik: falsk pause: 100 nyttelast: kilde: Keep_lambda_warmplugins: - Serverløs-plugin-Warmup

Det er ganske mange ting som skjer i denne filen.

Først definerte vi navnet på tjenesten vår:

service: ML-modell

For det andre definerte vi en global konfigurasjon:

rammeversjon: '3'

rammeversjonbrukes til å feste en spesifikk versjon av serverløse rammer.

For det tredje konfigurerte vi enforsørger:

forsørger: Navn: aws region: ${opt:region, 'eu-west-1'} scene: $ {opt: scene, 'utvikling'} LogretentionIndays: 90 ecr: Bilder: Appimage: sti: ./

Vi setter standardverdier for region og scene,Irland (EU-West-1)ogutviklinghenholdsvis.opt:regionogOPT: Stagekan leses inn fra kommandolinjen. For eksempel:

$ serverløs distribusjon-Region US-East-1-Stage Production

Deretter setter vi loggoppbevaringsdagene slik at alle logger innCloudWatchfra vår søknad vil bli slettet etter tretti dager. På slu*tten definerte vi at vi skal bruke et Docker-bilde for å distribuere ML-modellen vår. Det skal bygges på sti./og lagret inneECR.

For det fjerde definerte vi Lambda-funksjonen vår:

funksjoner: ML_MODEL: bilde: Navn: Appimage pause: 90 minnestørrelse: 4096 miljø: TORCH_HOME: /tmp/.ml_cache TRANSFORMERS_CACHE: /tmp/.ml_cache/huggingface

Siden vi bruker AWS-leverandøren, er alt definertfunksjonervil være AWS Lambda-funksjoner.

Vi spesifiserte hvilket Docker -bilde som skal brukes, som vil bli presset til ECR og lastet ned derfra.Da setter vi timeout og minnegrenser.Vi avslu*ttet funksjonens definisjon ved å stille inn skrivbare mapper forPytorchogHuggingFaceBiblioteker.Disse bibliotekene vil laste ned noen filer.Derfor må destinasjonen være skrivbar.Vi brukte en "/tmp" -mappe for det, som er den eneste mappen som er skrevet på AWS Lambda.

Med ML-biblioteker som Pytorch og Huggingface transformatorer, kan du bruke forhåndsutdannede modeller (som vi gjør).Disse modellene lastes ned fra Internett og lagres på disken - for å cache dem.På denne måten trenger du ikke å laste dem ned hver gang koden blir utført.Biblioteker sjekker alltid om de først kan laste modellen fra den lokale cachen.Hvis den ikke er der, laster de den ned.De bruker standardinnstillinger for cache -plasseringen.På Lambda er standardplassen ikke skrivbar.Bare "/tmp" -mappen er skrivbar.Derfor må vi sette cache -plasseringen inne i "/tmp".For å tydelig indikere at destinasjonen er cache -destinasjonen for ML -modellene, kalte vi den ".ml_cache".

For mer om tilpasning av PyTorch og HuggingFace sin cache, se gjennom følgende ressurser:

1. Pytorch:Hvor lagres mine nedlastede modeller?
2. HuggingFace:Caching-modeller

Ved å sette miljøvariablerTORCH_HOMEogTRANSFORMERS_CACHE, ba vi bibliotekene våre om å bruke denne plasseringen til hurtigbufring. Gi gjerne nytt navn til destinasjonen etter din smak.

Vi bruker 90 sekunder for timeout fordi modellen må lastes og dette kan ta litt tid.

For det femte spesifiserte vi konfigurasjon for vår Lambda's Warmer, som bare er en annen Lambda, for å holde kjernen Lambda varm:

tilpasset: varme opp: MlModelwarmer: aktivert: ekte Navn: $ {self: service}-$ {self: leverandør.stage} -warmer rollenavn: $ {self: service}-$ {self: leverandør.stage} -warmer-role arrangementer: - rute: rate (4 minutter) samtidighet: ${env:WARMER_CONCURRENCY, 2} ordrik: falsk pause: 100 nyttelast: kilde: Keep_lambda_warmplugins: - Serverløs-plugin-Warmup

Her brukte viServerløs-plugin-Warmupplugg inn.Legg merke tilnyttelast:

{ "kilde": "Keep_lambda_warm" }

Legg til følgendepackage.jsonFil også for å installere serverløs-plugin-warmup:

{ "Navn": "ML-modell", "versjon": "1.0.0", "beskrivelse": "", "hoved": "index.js", "avhengigheter": {}, "devDependencies": { "serverless-plugin-warmup": "8.2.1" }, "Skript": { "test": "Echo \" Feil: Ingen test spesifisert \ "&& Exit 1" }, "forfatter": "", "tillatelse": "ISC"}

Dockerfil

Det eneste som gjenstår før utplassering er vårDockerfil:

############ BYGGER ############FRA public.ecr.aws/lambda/python:3.10 som byggerLØPE PIP3 installasjon -Upgrade pipKOPIERE requirements.txt .LØPE pip3 install -r krav.txt -mål""$ {Lambda_task_root}"########## ENDELIG ##########FRA public.ecr.aws/lambda/python:3.10LØPE PIP3 installasjon -Upgrade pipKOPIERE --fra=bygger$ {LAMBDA_TASK_ROOT} $ {Lambda_task_root}KOPIERE .${LAMBDA_TASK_ROOT}CMD [ "handler.handle" ]

Så vi brukte et basisbilde for Lambda levert av AWS.Bildet er bygget i to trinn for å holde den endelige bildestørrelsen minimal.På slu*tten spesifiserte vi hvilken funksjon som vil bli kalt når lambda påberopes.

Prosjektkatalogen din skal nå se slik ut:

├── Dockerfile├── handler.py├── package.json├── requirements.txt├── sentiment_model.py└── serverless.yml

Implementering med GitHub Actions

Siden vi er sanne fa*gfolk, vil vi brukeGitHub -handlingerfor å implementere Lambda-funksjonen vår. For å gjøre det må vi først legge til en CI/CD-konfigurasjon.

Opprett følgende fil og mapper:

└── .github └── arbeidsflyter └── lambda.yml

Deretter legger du til CI/CD-konfigurasjonen til.github/workflows/lambda.yml:

Navn: ML Lambda Deploypå: trykk:env: AWS_ACCESS_KEY_ID: $ {{secrets.aws_access_key_id}} Aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} AWS_DEFAULT_REGION: eu-vest-1arbeidsplasser: distribusjonsutvikling: strategi: mislykkesfast: falsk matrise: Python-versjon: ['3.10'] node-versjon: [18] os: [Ubuntu-Latest] kjører på: ${{ matrix.os }} trinn: - Navn: Kassekode bruker: actions/checkout@v3 - Navn: Sett opp Python 3.10 bruker: Handlinger/oppsett-python@v3 med: python-versjon: $ {{matrix.python-versjon}} - bruker: Handlinger/setup-node@v3 med: Nodeversjon: $ {{Matrix.Node-Version}} - Navn: Installer Serverless Framework løpe: npm install -g serverløs - Navn: Installer NPM-avhengigheter løpe: NPM installasjon - Navn: Utplassere løpe: sls deploy --stage development --verbose

Inne i den nylig lagt til jobben,distribusjonsutvikling, vi:

1. Utarbeidet det grunnleggende miljøet ved å installere Python og Node.
2. Installert Serverless Framework som en global avhengighet -- så vi er i stand til å kjøreslskommandoer.
3. Installerte avhengigheter frapackage.json-- på dette tidspunktet er det bare serverless-plugin-warmup-plugin.
4. Distribuerte søknaden vår ved å kjøresls deploy --stage development --verbosekommando.

Du kan prøve å distribuere direkte fra datamaskinen til AWS ved å kjøreNPM installasjonogserverløs distribusjon -- trinnutviklinginne i "services/tasks_api". Du trenger Serverless Frameworkinstallerti tillegg tilnpm og Node.js. Du må også angi AWS-legitimasjonen din.

AWS -legitimasjon

Før du kan forplikte deg og pushe, må du legge til AWS-legitimasjon til GitHub.

Hvis du ikke har en AWS-konto ennå, opprett en fraAWS-konsoll.

Først, åpneJEG ERkonsoll. Klikk deretter "Legg til bruker". Tast inngithubfor brukernavnet. Klikk "Neste".

På neste trinn, velg "Fest retningslinjer direkte" og velg "AdministratorAccess".

Klikk "Neste" og deretter "Opprett bruker". Når brukeren din er opprettet (du vil se den i listen over brukere), klikk på den for å åpne detaljene. Når du er der, bytt til fanen "Sikkerhetslegitimasjon" og klikk på "Opprett tilgangsnøkkel".

Etter det, velg "Application running outside of AWS" og klikk "Next". På neste skjerm klikker du på "Opprett tilgangsnøkkel".

Etter at du har legitimasjon for dingithubIAM -bruker, du må legge dem til GitHub.For å gjøre det, gå til depotet ditt og klikk på "Innstillinger" -> "Hemmeligheter og variabler -> Handlinger".Deretter klikker du på "New Repository Secret".Skape en hemmelighet forAws_access_key_id.Deretter lage en annen forAws_secret_access_key.Sørg for å sette verdiene til verdiene for legitimasjonen du nettopp opprettet.

Forplikt deg og skyv koden din.

Sjekk rørledningens utgang for å sikre at den var vellykket. ForlengUtplasseretrinn inne idistribusjonsutviklingjobbens utgang for å se detaljene.

Det kan ta flere minutter før utplasseringen lykkes.

Ende-til-ende-test

Til slu*tt, la oss legge til en ende-til-ende-test for vår Lambda. På denne måten vil vi sørge for at Lambdaen vår fungerer som forventet. Det vil også gi et eksempel på bruken.

Først må du legge til Boto3 og Pytest tilkrav.txt:

BOTO3 == 1.28.25Pytest == 7.4.0Torch == 2.0.1Transformers == 4.31.0

For det andre, lag en ny modul kalttests.py:

import JSONimport Voulydef test_sentiment_er_predikert(): klient = Vouly.klient(«lambda») respons = klient.påkalle( Funksjonsnavn='ml-model-development-ml_model', InvocationType='RequestResponse', Nyttelast=json.dumper({ "tekst": "Jeg er så glad! Jeg elsker denne opplæringen! Du har virkelig gjort en god jobb!" }) ) hevde json.laster(respons["Nyttelast"].lese().dekode("utf-8"))["sentiment"] == "positiv"

Her brukte vi Boto3 for å starte Lambda-funksjonen vår. Vi vedtok teksten - en veldig positiv en - for å forutsi følelsen som en nyttelast. Så hevdet vi at følelsen er positiv.

Kjør gjerne testene dine lokalt viapython -m pytest tester.py. Bare sørg for å installere de nye avhengighetene. Du må ha AWS-legitimasjonen din konfigurert.

Legg til ende-til-ende testjobben i.github/workflows/lambda.yml

Navn: ML Lambda Deploypå: trykk:env: Aws_access_key_id: $ {{secrets.aws_access_key_id}} Aws_secret_access_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} AWS_DEFAULT_REGION: eu-vest-1 APP_EN -miljø: utvikling # Nyarbeidsplasser: distribusjonsutvikling: strategi: mislykkes raskt: falsk matrise: python-versjon: ['3.10'] node-versjon: [18] os: [Ubuntu-Latest] kjører på: ${{ matrix.os }} trinn: - Navn: Kassekode bruker: actions/checkout@v3 - Navn: Sett opp Python 3.10 bruker: Handlinger/oppsett-python@v3 med: python-versjon: $ {{matrix.python-versjon}} - bruker: Handlinger/setup-node@v3 med: Nodeversjon: $ {{Matrix.Node-Version}} - Navn: Installer serverløse rammer løpe: npm install -g serverløs - Navn: Installer NPM-avhengigheter løpe: NPM installasjon - Navn: Utplassere løpe: sls deploy --stage development --verbose E2E: # Ny behov: [distribusjonsutvikling] strategi: mislykkes raskt: falsk matrise: python-versjon: [ '3.10' ] os: [ Ubuntu-Latest ] kjører på: $ {{matrix.os}} trinn: - Navn: Kassekode bruker: Handlinger/kassa@v3 - Navn: Sett opp Python 3.10 bruker: Handlinger/oppsett-python@v3 med: python-versjon: $ {{matrix.python-versjon}} - Navn: Installer avhengigheter løpe: pip install -r requirements.txt - Navn: Kjør Pytest løpe: Pytest Tests.py

Det er det! Forplikt og trykk koden din. Du bør se rørledningen kjøre. Det bør lykkes.

Gratulerer!Nå har du en helautomatisert CI/CD -rørledning som distribuerer Lambda -funksjonen din som serverer ML -modellen.

Du kan ødelegge AWS-ressurser ved å erstattesls deploy --stage development --verbosemedsls fjern --stadiumutvikling --verboseinne idistribusjonsutviklingjobb.

Konklusjon

I denne opplæringen lærte du hvordan du distribuerer en ML -modell til AWS Lambda og hvordan du bruker den med BOTO3 -biblioteket.Du lærte også hvordan du lager en CI/CD-rørledning som distribuerer Lambda-funksjonen din automatisk og kjører ende-til-ende-tester for den.Du brukte serverløse rammer for å distribuere Lambda -funksjonen og GitHub -handlingene for å lage en CI/CD -rørledning.