Dataforskare tränar ofta sina modeller lokalt och letar efter en lämplig värdtjänst för att distribuera sina modeller. Tyvärr finns det ingen fast mekanism eller guide för att distribuera förtränade modeller till molnet. I det här inlägget tittar vi på att distribuera utbildade modeller till Amazon SageMaker hosting för att minska din distributionstid.

SageMaker är en fullständigt hanterad maskininlärningstjänst (ML). Med SageMaker kan du snabbt bygga och träna ML-modeller och distribuera dem direkt i en produktionsklar värdmiljö. Dessutom behöver du inte hantera servrar. Du får en integrerad Jupyter notebook-miljö med enkel åtkomst till dina datakällor. Du kan utföra dataanalys, träna dina modeller och testa dem med dina egna algoritmer eller använda SageMaker-försedda ML-algoritmer som är optimerade för att köras effektivt mot stora datamängder spridda över flera maskiner. Utbildning och värd faktureras per minuts användning, utan minimiavgifter och inga förhandsåtaganden.

Lösningsöversikt

Dataforskare utbildar ibland modeller lokalt med deras IDE och skickar antingen modellerna till ML-ingenjörsteamet för distribution eller kör bara förutsägelser lokalt på kraftfulla maskiner. I det här inlägget introducerar vi ett Python-bibliotek som förenklar processen att distribuera modeller till SageMaker för värd på realtids- eller serverlösa slutpunkter.

Detta Python-bibliotek ger dataforskare ett enkelt gränssnitt för att snabbt komma igång med SageMaker utan att behöva känna till någon av SageMaker-funktionerna på låg nivå.

Om du har modeller som tränas lokalt med din föredragna IDE och vill dra nytta av molnets skala, kan du använda det här biblioteket för att distribuera din modell till SageMaker. Med SageMaker, utöver alla skalfördelar med en molnbaserad ML-plattform, har du tillgång till specialbyggda träningsverktyg (distribuerad utbildning, hyperparameterjustering), experimenthantering, modellhantering, bias-detektering, modellförklarbarhet och många andra funktioner som kan hjälpa dig i alla aspekter av ML:s livscykel. Du kan välja bland de tre mest populära ramverken för ML: Scikit-learn, PyTorch och TensorFlow, och kan välja vilken typ av dator du vill ha. Standarder tillhandahålls längs vägen så att användare av det här biblioteket kan distribuera sina modeller utan att behöva fatta komplexa beslut eller lära sig nya koncept. I det här inlägget visar vi dig hur du kommer igång med det här biblioteket och optimerar distributionen av dina ML-modeller på SageMaker-värd.

Biblioteket finns i GitHub repository.

SageMaker Migration Toolkit

Smakämnen SageMakerMigration klass är tillgänglig via ett Python-bibliotek publicerat på GitHub. Instruktioner för att installera det här biblioteket finns i förvaret; se till att du följer README för att ställa in din miljö korrekt. När du har installerat det här biblioteket talar resten av det här inlägget om hur du kan använda det.

Smakämnen SageMakerMigration klass består av abstraktioner på hög nivå över SageMaker API:er som avsevärt minskar de steg som krävs för att distribuera din modell till SageMaker, som illustreras i följande figur. Detta är avsett för experiment så att utvecklare snabbt kan komma igång och testa SageMaker. Den är inte avsedd för produktionsmigreringar.

För Scikit-learn-, PyTorch- och TensorFlow-modeller stöder det här biblioteket distribution av tränade modeller till en SageMaker-slutpunkt i realtid eller en serverlös slutpunkt. För att lära dig mer om slutledningsalternativen i SageMaker, se Distribuera modeller för slutledning.

Slutpunkter i realtid kontra serverlösa

Realtidsinferens är idealisk för slutledningsarbetsbelastningar där du har interaktiva realtidskrav med låg latens. Du kan distribuera din modell till SageMakers värdtjänster och få en slutpunkt som kan användas för slutledning. Dessa slutpunkter är helt hanterade och stöder automatisk skalning.

SageMaker Serverless Inference är ett specialbyggt inferensalternativ som gör det enkelt för dig att distribuera och skala ML-modeller. Serverlös inferens är idealisk för arbetsbelastningar som har inaktiva perioder mellan trafiksprutor och som kan tolerera kallstarter. Serverlösa slutpunkter startar automatiskt beräkningsresurser och skalar in och ut dem beroende på trafik, vilket eliminerar behovet av att välja instanstyper eller hantera skalningspolicyer. Detta tar bort det odifferentierade tunga lyftet av att välja och hantera servrar.

Beroende på ditt användningsfall kanske du snabbt vill vara värd för din modell på SageMaker utan att faktiskt alltid ha en instans på och att ådra sig kostnader, i vilket fall en serverlös slutpunkt är en utmärkt lösning.

Förbered din tränade modell och slutledningsmanus

Efter att du har identifierat modellen du vill distribuera på SageMaker måste du se till att modellen presenteras för SageMaker i rätt format. SageMaker-slutpunkter består i allmänhet av två komponenter: den tränade modellartefakten (.pth, .pkl, och så vidare) och ett slutledningsskript. Slutledningsskriptet är inte alltid obligatoriskt, men om det inte tillhandahålls, tillämpas standardhanterarna för den serveringsbehållare som du använder. Det är viktigt att tillhandahålla detta skript om du behöver anpassa din inmatnings-/utdatafunktionalitet för slutledning.

Den tränade modellartefakten är helt enkelt en sparad Scikit-learn-, PyTorch- eller TensorFlow-modell. För Scikit-learn är detta vanligtvis en pickle-fil, för PyTorch är detta en .pt- eller .pth-fil, och för TensorFlow är detta en mapp med tillgångar, .pb-filer och andra variabler.

Generellt måste du kunna kontrollera hur din modell bearbetar input och utför slutledning, och kontrollera utdataformatet för ditt svar. Med SageMaker kan du tillhandahålla en slutledningsskrift för att lägga till denna anpassning. Alla slutledningsskript som används av SageMaker måste ha en eller flera av följande fyra hanterarfunktioner: model_fn, input_fn, predict_fnoch output_fn.

Observera att dessa fyra funktioner gäller PyTorch och Scikit lära behållare specifikt. TensorFlow har lite olika hanterare eftersom det är integrerat med TensorFlow-servering. För ett slutledningsskript med TensorFlow har du två modellhanterare: input_handler och output_handler. Återigen, dessa har samma förbearbetnings- och efterbearbetningsändamål som du kan arbeta med, men de är konfigurerade något annorlunda för att integreras med TensorFlow-servering. För PyTorch-modeller är model_fn en obligatorisk funktion att ha i inferensskriptet.

modell_fn

Detta är den funktion som först anropas när du anropar din SageMaker-slutpunkt. Det är här du skriver din kod för att ladda modellen. Till exempel:

def model_fn(model_dir):
    model = Your_Model()
    with open(os.path.join(model_dir, 'model.pth'), 'rb') as f:
        model.load_state_dict(torch.load(f))
    return model

Beroende på ramverket och typen av modell kan denna kod ändras, men funktionen måste returnera en initierad modell.

input_fn

Detta är den andra funktionen som anropas när din slutpunkt anropas. Denna funktion tar data som skickas till slutpunkten för slutledning och analyserar den till det format som krävs för att modellen ska generera en förutsägelse. Till exempel:

def input_fn(request_body, request_content_type):
    """An input_fn that loads a pickled tensor"""
    if request_content_type == 'application/python-pickle':
        return torch.load(BytesIO(request_body))
    else:
        # Handle other content-types here or raise an Exception
        # if the content type is not supported.
        pass

Smakämnen request_body innehåller data som ska användas för att generera slutledning från modellen och analyseras i den här funktionen så att den är i det format som krävs.

förutsäga_fn

Detta är den tredje funktionen som anropas när din modell anropas. Denna funktion tar den förbehandlade indata som returneras från input_fn och använder modellen som returneras från model_fn att göra förutsägelsen. Till exempel:

def predict_fn(input_data, model):
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)
    model.eval()
    with torch.no_grad():
        return model(input_data.to(device))

Du kan valfritt lägga till output_fn att analysera resultatet av predict_fn innan den returneras till kunden. Funktionssignaturen är def output_fn(prediction, content_type).

Flytta din förtränade modell till SageMaker

När du har din tränade modellfil och inferensskript måste du lägga dessa filer i en mapp enligt följande:

#SKLearn Model

model_folder/
    model.pkl
    inference.py
    
# Tensorflow Model
model_folder/
    0000001/
        assets/
        variables/
        keras_metadata.pb
        saved_model.pb
    inference.py
    
# PyTorch Model
model_folder/
    model.pth
    inference.py

Efter att din modell och inferensskript har förberetts och sparats i den här mappstrukturen är din modell redo för distribution på SageMaker. Se följande kod:

from sagemaker_migration import frameworks as fwk

if __name__ == "__main__":
    ''' '''
    sk_model = fwk.SKLearnModel(
        version = "0.23-1", 
        model_data = 'model.joblib',
        inference_option = 'real-time',
        inference = 'inference.py',
        instance_type = 'ml.m5.xlarge'
    )
    sk_model.deploy_to_sagemaker()

Efter implementeringen av din slutpunkt, se till att rensa upp alla resurser som du inte kommer att använda via SageMaker-konsolen eller via delete_endpoint Boto3 API-anrop.

Slutsats

Målet med SageMaker Migration Toolkit-projektet är att göra det enkelt för datavetare att integrera sina modeller på SageMaker för att dra fördel av molnbaserad slutledning. Förvaret kommer att fortsätta att utvecklas och stödja fler alternativ för att migrera arbetsbelastningar till SageMaker. Koden är öppen källkod och vi välkomnar bidrag från communityn genom pull-förfrågningar och frågor.

Kolla in GitHub repository för att utforska mer om att använda SageMaker Migration Toolkit, och gärna också bidra med exempel eller funktionsförfrågningar att lägga till i projektet!

Om författarna

Kirit Thadaka är en ML Solutions Architect som arbetar i Amazon SageMaker Service SA-teamet. Innan Kirit började på AWS tillbringade Kirit tid med att arbeta i AI-startups i ett tidigt skede, följt av lite tid med konsultation i olika roller inom AI-forskning, MLOps och tekniskt ledarskap.

Ram Vegiraju är en ML-arkitekt med SageMaker Service-teamet. Han fokuserar på att hjälpa kunder att bygga och optimera sina AI/ML-lösningar på Amazon SageMaker. På fritiden älskar han att resa och skriva.