Zephyrnet-logo

Reduser kostnader og utviklingstid med Amazon SageMaker Pipelines lokal modus

Dato:

Å lage robuste og gjenbrukbare maskinlæring (ML) pipelines kan være en kompleks og tidkrevende prosess. Utviklere tester vanligvis prosesserings- og opplæringsskriptene sine lokalt, men selve rørledningene testes vanligvis i skyen. Å opprette og kjøre en full pipeline under eksperimentering legger til uønskede overhead og kostnader til utviklingslivssyklusen. I dette innlegget beskriver vi hvordan du kan bruke Amazon SageMaker Pipelines lokal modus å kjøre ML-rørledninger lokalt for å redusere både rørledningsutvikling og kjøretid samtidig som kostnadene reduseres. Etter at rørledningen er ferdig testet lokalt, kan du enkelt kjøre den på nytt med Amazon SageMaker administrerte ressurser med bare noen få linjer med kodeendringer.

Oversikt over ML livssyklus

En av hoveddriverne for nye innovasjoner og applikasjoner i ML er tilgjengeligheten og mengden data sammen med billigere beregningsalternativer. På flere domener har ML vist seg i stand til å løse problemer som tidligere var uløselige med klassisk big data og analytiske teknikker, og etterspørselen etter datavitenskap og ML-utøvere øker jevnt. Fra et veldig høyt nivå består ML-livssyklusen av mange forskjellige deler, men byggingen av en ML-modell består vanligvis av følgende generelle trinn:

  1. Datarensing og klargjøring (funksjonsteknikk)
  2. Modelltrening og tuning
  3. Modellevaluering
  4. Modellimplementering (eller batchtransformasjon)

I dataforberedelsestrinnet blir data lastet inn, massert og transformert til den typen innganger eller funksjoner som ML-modellen forventer. Å skrive skriptene for å transformere dataene er vanligvis en iterativ prosess, der raske tilbakemeldingssløyfer er viktige for å fremskynde utviklingen. Det er normalt ikke nødvendig å bruke hele datasettet når du tester funksjonsteknikkskript, og det er derfor du kan bruke lokal modus funksjon fra SageMaker Processing. Dette lar deg kjøre lokalt og oppdatere koden iterativt ved å bruke et mindre datasett. Når den endelige koden er klar, sendes den til fjernbehandlingsjobben, som bruker hele datasettet og kjører på SageMaker-administrerte forekomster.

Utviklingsprosessen ligner på dataforberedelsestrinnet for både modelltrening og modellevalueringstrinn. Dataforskere bruker lokal modus funksjon av SageMaker Training for å iterere raskt med mindre datasett lokalt, før du bruker alle dataene i en SageMaker-administrert klynge av ML-optimaliserte forekomster. Dette fremskynder utviklingsprosessen og eliminerer kostnadene ved å kjøre ML-forekomster administrert av SageMaker mens du eksperimenterer.

Etter hvert som en organisasjons ML-modenhet øker, kan du bruke Amazon SageMaker-rørledninger å lage ML-rørledninger som setter sammen disse trinnene, og skaper mer komplekse ML-arbeidsflyter som behandler, trener og evaluerer ML-modeller. SageMaker Pipelines er en fullstendig administrert tjeneste for å automatisere de forskjellige trinnene i ML-arbeidsflyten, inkludert datainnlasting, datatransformasjon, modelltrening og justering, og modellimplementering. Inntil nylig kunne du utvikle og teste skriptene dine lokalt, men måtte teste ML-rørledningene dine i skyen. Dette gjorde iterasjon av flyten og formen til ML-rørledninger til en langsom og kostbar prosess. Nå, med den ekstra lokale modusfunksjonen til SageMaker Pipelines, kan du iterere og teste ML-pipelines på samme måte som hvordan du tester og itererer på prosesserings- og treningsskriptene dine. Du kan kjøre og teste pipelines på din lokale maskin, ved å bruke et lite delsett av data for å validere pipeline-syntaksen og funksjonene.

SageMaker-rørledninger

SageMaker Pipelines gir en helautomatisert måte å kjøre enkle eller komplekse ML-arbeidsflyter. Med SageMaker Pipelines kan du lage ML-arbeidsflyter med en brukervennlig Python SDK, og deretter visualisere og administrere arbeidsflyten din ved å bruke Amazon SageMaker Studio. Datavitenskapsteamene dine kan bli mer effektive og skalere raskere ved å lagre og gjenbruke arbeidsflyttrinnene du oppretter i SageMaker Pipelines. Du kan også bruke forhåndsbygde maler som automatiserer opprettelsen av infrastruktur og depot for å bygge, teste, registrere og distribuere modeller i ML-miljøet ditt. Disse malene er automatisk tilgjengelige for organisasjonen din og klargjøres ved hjelp av AWS servicekatalog produkter.

SageMaker Pipelines bringer kontinuerlig integrasjon og kontinuerlig distribusjon (CI/CD)-praksis til ML, som å opprettholde paritet mellom utviklings- og produksjonsmiljøer, versjonskontroll, testing på forespørsel og ende-til-ende-automatisering, som hjelper deg med å skalere ML gjennom hele organisasjon. DevOps-utøvere vet at noen av hovedfordelene ved å bruke CI/CD-teknikker inkluderer en økning i produktivitet via gjenbrukbare komponenter og en økning i kvalitet gjennom automatisert testing, noe som fører til raskere ROI for forretningsmålene dine. Disse fordelene er nå tilgjengelige for MLOps-utøvere ved å bruke SageMaker Pipelines for å automatisere opplæring, testing og distribusjon av ML-modeller. Med lokal modus kan du nå iterere mye raskere mens du utvikler skript for bruk i en pipeline. Merk at lokale pipeline-forekomster ikke kan vises eller kjøres i Studio IDE; Imidlertid vil ytterligere visningsalternativer for lokale rørledninger være tilgjengelig snart.

SageMaker SDK gir et generelt formål lokal moduskonfigurasjon som lar utviklere kjøre og teste støttede prosessorer og estimatorer i deres lokale miljø. Du kan bruke lokal modustrening med flere AWS-støttede rammeverksbilder (TensorFlow, MXNet, Chainer, PyTorch og Scikit-Learn) samt bilder du selv leverer.

SageMaker Pipelines, som bygger en Directed Acyclic Graph (DAG) av orkestrerte arbeidsflyttrinn, støtter mange aktiviteter som er en del av ML-livssyklusen. I lokal modus støttes følgende trinn:

  • Behandler jobbtrinn – En forenklet, administrert opplevelse på SageMaker for å kjøre databehandlingsarbeidsbelastninger, for eksempel funksjonsutvikling, datavalidering, modellevaluering og modelltolkning
  • Treningsjobbtrinn – En iterativ prosess som lærer en modell å lage spådommer ved å presentere eksempler fra et treningsdatasett
  • Hyperparameter tuning jobber – En automatisert måte å evaluere og velge hyperparametrene som gir den mest nøyaktige modellen
  • Betingede løpstrinn – Et trinn som gir et betinget løp av grener i en rørledning
  • Modelltrinn – Ved å bruke CreateModel-argumenter kan dette trinnet lage en modell for bruk i transformasjonstrinn eller senere distribusjon som et endepunkt
  • Forvandle jobbtrinn – En batch-transformeringsjobb som genererer spådommer fra store datasett, og kjører inferens når et vedvarende endepunkt ikke er nødvendig
  • Feil trinn – Et trinn som stopper en rørledningskjøring og markerer kjøringen som mislykket

Løsningsoversikt

Løsningen vår viser de essensielle trinnene for å lage og kjøre SageMaker Pipelines i lokal modus, som betyr å bruke lokale CPU-, RAM- og diskressurser for å laste og kjøre arbeidsflyttrinnene. Ditt lokale miljø kan kjøres på en bærbar datamaskin, ved å bruke populære IDE-er som VSCode eller PyCharm, eller det kan være vert for SageMaker ved å bruke klassiske notebook-forekomster.

Lokal modus lar dataforskere sy sammen trinn, som kan inkludere prosesserings-, opplærings- og evalueringsjobber, og kjøre hele arbeidsflyten lokalt. Når du er ferdig med å teste lokalt, kan du kjøre pipelinen på nytt i et SageMaker-administrert miljø ved å erstatte LocalPipelineSession objekt med PipelineSession, som gir konsistens til ML-livssyklusen.

For dette notatbokeksemplet bruker vi et standard offentlig tilgjengelig datasett, den UCI Machine Learning Abalone Datasett. Målet er å trene en ML-modell for å bestemme alderen til en fjølsnegl ut fra dens fysiske mål. I kjernen er dette et regresjonsproblem.

All koden som kreves for å kjøre denne bærbare prøven er tilgjengelig på GitHub i amazon-sagemaker-eksempler oppbevaringssted. I dette notatbokeksemplet opprettes hvert rørledningsarbeidsflyttrinn uavhengig og deretter koblet sammen for å lage rørledningen. Vi lager følgende trinn:

  • Behandlingstrinn (funksjonsteknikk)
  • Treningstrinn (modelltrening)
  • Behandlingstrinn (modellevaluering)
  • Tilstandstrinn (modellnøyaktighet)
  • Lag modelltrinn (modell)
  • Transformeringstrinn (batchtransformasjon)
  • Registrer modelltrinn (modellpakke)
  • Feil trinn (kjøring mislyktes)

Følgende diagram illustrerer rørledningen vår.

Forutsetninger

For å følge med i dette innlegget trenger du følgende:

Etter at disse forutsetningene er på plass, kan du kjøre eksempelnotisboken som beskrevet i de følgende delene.

Bygg rørledningen din

I dette notatbokeksemplet bruker vi SageMaker skriptmodus for de fleste ML-prosessene, noe som betyr at vi gir den faktiske Python-koden (skript) for å utføre aktiviteten og sende en referanse til denne koden. Skriptmodus gir stor fleksibilitet til å kontrollere atferden i SageMaker-behandlingen ved å la deg tilpasse koden din samtidig som du drar nytte av SageMaker forhåndsbygde containere som XGBoost eller Scikit-Learn. Den egendefinerte koden skrives til en Python-skriptfil ved hjelp av celler som begynner med den magiske kommandoen %%writefile, som følgende:

%%writefile code/evaluation.py

Den primære aktivatoren for lokal modus er LocalPipelineSession objekt, som er instansiert fra Python SDK. Følgende kodesegmenter viser hvordan du oppretter en SageMaker-pipeline i lokal modus. Selv om du kan konfigurere en lokal databane for mange av de lokale pipeline-trinnene, er Amazon S3 standardplasseringen for å lagre datautdataene ved transformasjonen. Den nye LocalPipelineSession objektet sendes til Python SDK i mange av SageMaker arbeidsflyt API-kallene beskrevet i dette innlegget. Legg merke til at du kan bruke local_pipeline_session variabel for å hente referanser til S3 standard bøtte og gjeldende regionnavn.

from sagemaker.workflow.pipeline_context import LocalPipelineSession

# Create a `LocalPipelineSession` object so that each 
# pipeline step will run locally
# To run this pipeline in the cloud, you must change 
# the `LocalPipelineSession()` to `PipelineSession()`
local_pipeline_session = LocalPipelineSession()
region = local_pipeline_session.boto_region_name

default_bucket = local_pipeline_session.default_bucket()
prefix = "sagemaker-pipelines-local-mode-example"

Før vi oppretter de individuelle pipeline-trinnene, setter vi noen parametere som brukes av pipeline. Noen av disse parameterne er strenge bokstaver, mens andre er opprettet som spesielle oppregnede typer levert av SDK. Den oppregnede skrivingen sikrer at gyldige innstillinger gis til rørledningen, for eksempel denne, som sendes til ConditionLessThanOrEqualTo gå lenger ned:

mse_threshold = ParameterFloat(name="MseThreshold", default_value=7.0)

For å lage et databehandlingstrinn, som her brukes til å utføre funksjonsutvikling, bruker vi SKLearnProcessor for å laste og transformere datasettet. Vi passerer local_pipeline_session variabel til klassekonstruktøren, som instruerer arbeidsflyttrinnet til å kjøre i lokal modus:

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=local_pipeline_session,
)

Deretter lager vi vårt første faktiske rørledningstrinn, a ProcessingStep objekt, som importert fra SageMaker SDK. Prosessorargumentene returneres fra et kall til SKLearnProcessor run() metode. Dette arbeidsflyttrinnet er kombinert med andre trinn mot slutten av den bærbare datamaskinen for å indikere operasjonsrekkefølgen i rørledningen.

from sagemaker.processing import ProcessingInput, ProcessingOutput
from sagemaker.workflow.steps import ProcessingStep

processor_args = sklearn_processor.run(
    inputs=[
        ProcessingInput(source=input_data, destination="/opt/ml/processing/input"),
    ],
    outputs=[
        ProcessingOutput(output_name="train", source="/opt/ml/processing/train"),
        ProcessingOutput(output_name="validation", source="/opt/ml/processing/validation"),
        ProcessingOutput(output_name="test", source="/opt/ml/processing/test"),
    ],
    code="code/preprocessing.py",
)

step_process = ProcessingStep(name="AbaloneProcess", step_args=processor_args)

Deretter gir vi kode for å etablere et opplæringstrinn ved først å instansiere en standard estimator ved å bruke SageMaker SDK. Vi passerer det samme local_pipeline_session variabel til estimatoren, kalt xgb_train, som sagemaker_session argument. Fordi vi ønsker å trene en XGBoost-modell, må vi generere en gyldig bilde-URI ved å spesifisere følgende parametere, inkludert rammeverket og flere versjonsparametere:

from sagemaker.estimator import Estimator
from sagemaker.inputs import TrainingInput

model_path = f"s3://{default_bucket}/{prefix}/model"
image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.5-1",
    py_version="py3",
    instance_type=instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    entry_point="code/abalone.py",
    instance_type=instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    role=role,
    sagemaker_session=local_pipeline_session,
)

Vi kan valgfritt kalle ytterligere estimatormetoder, for eksempel set_hyperparameters(), for å gi hyperparameterinnstillinger for treningsjobben. Nå som vi har konfigurert en estimator, er vi klare til å lage selve treningstrinnet. Nok en gang importerer vi TrainingStep klasse fra SageMaker SDK-biblioteket:

from sagemaker.workflow.steps import TrainingStep

step_train = TrainingStep(name="AbaloneTrain", step_args=train_args)

Deretter bygger vi et annet behandlingstrinn for å utføre modellevaluering. Dette gjøres ved å lage en ScriptProcessor instans og passerer local_pipeline_session objekt som en parameter:

from sagemaker.processing import ScriptProcessor

script_eval = ScriptProcessor(
    image_uri=image_uri,
    command=["python3"],
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="script-abalone-eval",
    role=role,
    sagemaker_session=local_pipeline_session,
)

For å muliggjøre distribusjon av den trente modellen, enten til en SageMaker sanntidsendepunkt eller til en batch-transformasjon, må vi lage en Model objekt ved å sende modellartefakter, riktig bilde-URI, og eventuelt vår egendefinerte slutningskode. Da passerer vi dette Model motsette seg en ModelStep, som legges til den lokale rørledningen. Se følgende kode:

from sagemaker.model import Model

model = Model(
    image_uri=image_uri,
    model_data=step_train.properties.ModelArtifacts.S3ModelArtifacts,
    source_dir="code",
    entry_point="inference.py",
    role=role,
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.model_step import ModelStep

step_create_model = ModelStep(name="AbaloneCreateModel", 
    step_args=model.create(instance_type=instance_type)
)

Deretter lager vi et batch-transformeringstrinn der vi sender inn et sett med funksjonsvektorer og utfører inferens. Vi må først lage en Transformer objekt og passere local_pipeline_session parameter til den. Så lager vi en TransformStep, sender de nødvendige argumentene, og legg dette til pipelinedefinisjonen:

from sagemaker.transformer import Transformer

transformer = Transformer(
    model_name=step_create_model.properties.ModelName,
    instance_type=instance_type,
    instance_count=transform_instance_count,
    output_path=f"s3://{default_bucket}/{prefix}/transform",
    sagemaker_session=local_pipeline_session,
)

from sagemaker.workflow.steps import TransformStep

transform_args = transformer.transform(transform_data, content_type="text/csv")

step_transform = TransformStep(name="AbaloneTransform", step_args=transform_args)

Til slutt ønsker vi å legge til en grenbetingelse i arbeidsflyten slik at vi kun kjører batchtransformasjon hvis resultatene av modellevaluering oppfyller våre kriterier. Vi kan indikere dette betinget ved å legge til en ConditionStep med en bestemt tilstandstype, som ConditionLessThanOrEqualTo. Vi oppregner deretter trinnene for de to grenene, og definerer i hovedsak hvis/annet eller sant/falsk grenene til rørledningen. Hvis_trinnene som er angitt i ConditionStep (step_create_model, step_transform) kjøres når tilstanden evalueres til True.

from sagemaker.workflow.conditions import ConditionLessThanOrEqualTo
from sagemaker.workflow.condition_step import ConditionStep
from sagemaker.workflow.functions import JsonGet

cond_lte = ConditionLessThanOrEqualTo(
    left=JsonGet(
        step_name=step_eval.name,
        property_file=evaluation_report,
        json_path="regression_metrics.mse.value",),
    right=mse_threshold,
)

step_cond = ConditionStep(
    name="AbaloneMSECond",
    conditions=[cond_lte],
    if_steps=[step_create_model, step_transform],
    else_steps=[step_fail],
)

Følgende diagram illustrerer denne betingede grenen og de tilhørende if/else-trinnene. Bare én gren kjøres, basert på resultatet av modellevalueringstrinnet sammenlignet i tilstandstrinnet.

Nå som vi har alle trinnene våre definert, og de underliggende klasseforekomstene opprettet, kan vi kombinere dem til en pipeline. Vi gir noen parametere, og definerer operasjonsrekkefølgen ved ganske enkelt å liste trinnene i ønsket rekkefølge. Merk at TransformStep vises ikke her fordi det er målet for det betingede trinnet, og ble gitt som trinnargument til ConditionalStep Tidligere.

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=local_pipeline_session,
)

For å kjøre rørledningen må du kalle to metoder: pipeline.upsert(), som laster opp rørledningen til den underliggende tjenesten, og pipeline.start(), som begynner å kjøre rørledningen. Du kan bruke forskjellige andre metoder for å undersøke kjørestatusen, liste opp pipeline-trinnene og mer. Fordi vi brukte pipeline-økten for lokal modus, kjøres alle disse trinnene lokalt på prosessoren din. Celleutgangen under startmetoden viser utgangen fra rørledningen:

pipeline.upsert(role_arn=role)
execution = pipeline.start()

Du bør se en melding nederst på celleutgangen som ligner på følgende:

Pipeline execution d8c3e172-089e-4e7a-ad6d-6d76caf987b7 SUCCEEDED

Gå tilbake til administrerte ressurser

Etter at vi har bekreftet at rørledningen går uten feil og vi er fornøyd med flyten og formen på rørledningen, kan vi gjenskape rørledningen, men med SageMaker administrerte ressurser og kjøre den på nytt. Den eneste endringen som kreves er å bruke PipelineSession objekt i stedet for LocalPipelineSession:

fra sagemaker.workflow.pipeline_context importer LocalPipelineSession
from sagemaker.workflow.pipeline_context import PipelineSession

local_pipeline_session = LocalPipelineSession()
pipeline_session = PipelineSession()

Dette informerer tjenesten om å kjøre hvert trinn som refererer til dette sesjonsobjektet på SageMaker administrerte ressurser. Gitt den lille endringen, illustrerer vi bare de nødvendige kodeendringene i følgende kodecelle, men den samme endringen må implementeres på hver celle ved å bruke local_pipeline_session gjenstand. Endringene er imidlertid identiske på tvers av alle celler fordi vi bare erstatter local_pipeline_session objektet med pipeline_session gjenstand.

from sagemaker.sklearn.processing import SKLearnProcessor

framework_version = "1.0-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-abalone-process",
    role=role,
    sagemaker_session=pipeline_session,  # non-local session
)

Etter at det lokale sesjonsobjektet har blitt erstattet overalt, gjenskaper vi rørledningen og kjører den med SageMaker administrerte ressurser:

from sagemaker.workflow.pipeline import Pipeline

pipeline_name = f"LocalModelPipeline"
pipeline = Pipeline(
    name=pipeline_name,
    parameters=[
        input_data,
        mse_threshold,
    ],
    steps=[step_process, step_train, step_eval, step_cond],
    sagemaker_session=pipeline_session, # non-local session
)

pipeline.upsert(role_arn=role)
execution = pipeline.start()

Rydd opp

Hvis du vil holde Studio-miljøet ryddig, kan du bruke følgende metoder for å slette SageMaker-pipelinen og modellen. Hele koden finner du i prøven bærbare.

# delete models 
sm_client = boto3.client("sagemaker")
model_prefix="AbaloneCreateModel"
delete_models(sm_client, model_prefix)

# delete managed pipeline
pipeline_to_delete = 'SM-Managed-Pipeline'
delete_sagemaker_pipeline(sm_client, pipeline_to_delete)

konklusjonen

Inntil nylig kunne du bruke lokalmodusfunksjonen til SageMaker Processing og SageMaker Training for å iterere på prosesserings- og treningsskriptene dine lokalt, før du kjører dem på alle dataene med SageMaker administrerte ressurser. Med den nye lokalmodusfunksjonen til SageMaker Pipelines kan ML-utøvere nå bruke den samme metoden når de itererer på ML-rørledningene sine, og sy sammen de forskjellige ML-arbeidsflytene. Når rørledningen er klar for produksjon, krever det bare noen få linjer med kodeendringer å kjøre den med SageMaker administrerte ressurser. Dette reduserer pipeline-kjøringstiden under utvikling, noe som fører til raskere pipeline-utvikling med raskere utviklingssykluser, samtidig som kostnadene for SageMaker administrerte ressurser reduseres.

For å lære mer, besøk Amazon SageMaker-rørledninger or Bruk SageMaker Pipelines til å kjøre jobbene dine lokalt.


Om forfatterne

Paul Hargis har fokusert sin innsats på maskinlæring hos flere selskaper, inkludert AWS, Amazon og Hortonworks. Han liker å bygge teknologiske løsninger og lære folk hvordan de kan få mest mulig ut av det. Før han begynte i AWS, var han hovedarkitekt for Amazon Exports and Expansions, og hjalp amazon.com med å forbedre opplevelsen for internasjonale shoppere. Paul liker å hjelpe kunder med å utvide sine maskinlæringsinitiativer for å løse problemer i den virkelige verden.

Niklas Palm er Solutions Architect hos AWS i Stockholm, Sverige, hvor han hjelper kunder over hele Norden med å lykkes i skyen. Han er spesielt lidenskapelig opptatt av serverløse teknologier sammen med IoT og maskinlæring. Utenom jobben er Niklas en ivrig langrenns- og snowboardkjører samt en mester eggkoker.

Kirit Thadaka er en ML Solutions Architect som jobber i SageMaker Service SA-teamet. Før hun begynte i AWS, jobbet Kirit i AI-startups på tidlig stadium, etterfulgt av litt tid med rådgivning i ulike roller innen AI-forskning, MLOps og teknisk ledelse.

spot_img

Siste etterretning

spot_img