Lag Amazon SageMaker-modeller ved å bruke PyTorch Model Zoo

Utplassering av høykvalitets, trente maskinlæringsmodeller (ML) for å utføre enten batch- eller sanntidsslutning er en kritisk del av å bringe verdi til kundene. Imidlertid kan ML-eksperimenteringsprosessen være kjedelig - det er mange tilnærminger som krever en betydelig mengde tid å implementere. Det er derfor ferdigtrente ML-modeller som de som er gitt i PyTorch Model Zoo er så hjelpsomme. Amazon SageMaker gir et enhetlig grensesnitt for å eksperimentere med forskjellige ML-modeller, og PyTorch Model Zoo lar oss enkelt bytte ut modellene våre på en standardisert måte.

Dette blogginnlegget demonstrerer hvordan du utfører ML-inferens ved å bruke en objektdeteksjonsmodell fra PyTorch Model Zoo i SageMaker. Forhåndsutdannede ML-modeller fra PyTorch Model Zoo er ferdiglagde og kan enkelt brukes som en del av ML-applikasjoner. Sette opp disse ML-modellene som et SageMaker-endepunkt eller SageMaker Batch Transform jobb for online eller offline slutninger er enkelt med trinnene som er skissert i dette blogginnlegget. Vi vil bruke en Raskere R-CNN objektdeteksjonsmodell for å forutsi avgrensende bokser for forhåndsdefinerte objektklasser.

Vi går gjennom et ende-til-ende eksempel, fra lasting av Faster R-CNN-objektdeteksjonsmodellvektene, til å lagre dem til en Amazon Simple Storage Service (Amazon S3) bøtte, og for å skrive en inngangspunktfil og forstå nøkkelparametrene i PyTorchModel API. Til slutt vil vi distribuere ML-modellen, utføre slutninger om den ved hjelp av SageMaker Batch Transform, og inspisere ML-modellens utdata og lære hvordan du tolker resultatene. Denne løsningen kan brukes på alle andre forhåndstrente modeller på PyTorch Model Zoo. For en liste over tilgjengelige modeller, se PyTorch Model Zoo-dokumentasjon.

Løsningsoversikt

Dette blogginnlegget vil gå gjennom følgende trinn. For en fullstendig fungerende versjon av alle trinn, se create_pytorch_model_sagemaker.ipynb

• Trinn 1: Oppsett
• Trinn 2: Laster inn en ML-modell fra PyTorch Model Zoo
• Trinn 3 Lagre og last opp ML-modellartefakter til Amazon S3
• Trinn 4: Bygg ML-modellslutningsskript
• Trinn 5: Lansering av en SageMaker batch-transformeringsjobb
• Trinn 6: Visualisere resultater

Arkitektur diagram

katalog~~POS=TRUNC struktur~~POS=HEADCOMP

Koden til denne bloggen finner du i denne GitHub repository. Kodebasen inneholder alt vi trenger for å bygge ML-modellartefakter, starte transformasjonsjobben og visualisere resultater.

Dette er arbeidsflyten vi bruker. Alle de følgende trinnene vil referere til moduler i denne strukturen.

sagemaker_pytorch_model_zoo --> root directory
    |- inference.py --> entry point file
    |- create_pytorch_model_sagemaker.ipynb --> walks through all steps in this blog post
    |- cars.jpg --> input image

De sagemaker_torch_model_zoo mappen skal inneholde inference.py som en inngangspunktfil, og create_pytorch_model_sagemaker.ipynb for å laste og lagre modellvektene, lage et SageMaker-modellobjekt og til slutt overføre det til en SageMaker batch-transformeringsjobb. For å ta med dine egne ML-modeller, endre banene i trinn 1: oppsett-delen av den bærbare datamaskinen og last inn en ny modell i trinn 2: Laste en ML-modell fra PyTorch Model Zoo-delen. Resten av de følgende trinnene nedenfor forblir de samme.

Trinn 1: Oppsett

IAM-roller

SageMaker utfører operasjoner på infrastruktur som administreres av SageMaker. SageMaker kan bare utføre handlinger som er tillatt som definert i notatbokens medfølgende IAM-utførelsesrolle for SageMaker. For mer detaljert dokumentasjon om oppretting av IAM-roller og administrering av IAM-tillatelser, se AWS SageMaker rolledokumentasjon. Vi kan opprette en ny rolle, eller vi kan få den SageMaker (Studio) notatboksin standard utførelsesrolle ved å kjøre følgende linjer med kode:

import sagemaker

session = sagemaker.Session()

# Set a default S3 bucket
default_bucket = session.default_bucket()

# Get the region
region = boto3.Session().region_name

# Get the SageMaker Execution Role
role_arn = sagemaker.get_execution_role()

Koden ovenfor får SageMaker-utførelsesrollen for den bærbare forekomsten. Dette er IAM-rollen som vi opprettet for vår SageMaker- eller SageMaker Studio-notebook-forekomst.

Brukerkonfigurerbare parametere

Her er alle de konfigurerbare parameterne som trengs for å bygge og lansere vår SageMaker batch-transformeringsjobb:

INSTANCE_TYPE= "ml.m5.xlarge"
INSTANCE_COUNT= 1
BUCKET = os.path.join("s3://", default_bucket)

DATA_PATH= os.path.join(BUCKET, "images")
IMAGE_NAME = "cars.jpg"
RANDOM_STRING_LENGTH= 16
MODEL_NAME= "FasterRCNNResnet50"

# Needs to be set to version 1.2 or higher to enable automatic PyTorch model repackaging
FRAMEWORK_VERSION= "1.2"
ENTRY_POINT_FILE_NAME= "inference.py"

SAGEMAKER_EXECUTION_ROLE_ARN= role_arn
MODEL_ARTIFACTS_FILE_NAME= os.path.join(BUCKET, "modelzoo/fasterrcnn_resnet50_fpn/model.tar.gz")
IMAGE_URI= sagemaker.image_uris.retrieve(framework="pytorch",
region=region,
version="1.9.1",
py_version="py38",
image_scope='inference',
instance_type=INSTANCE_TYPE)

Trinn 2: Laster inn en ML-modell fra PyTorch Model Zoo

Deretter spesifiserer vi en objektdeteksjonsmodell fra PyTorch Model Zoo og lagrer ML-modellvektene. Vanligvis lagrer vi en PyTorch-modell ved hjelp av filtypene .pt eller .pth. Kodebiten nedenfor laster ned en forhåndstrent Faster R-CNN ResNet50 ML-modell fra PyTorch Model Zoo:

model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)

SageMaker batchtransformasjon krever som input noen modellvekter, så vi vil lagre den forhåndstrente ML-modellen som model.pt. Hvis vi ønsker å laste inn en tilpasset modell, kan vi lagre modellvektene fra en annen PyTorch-modell som model.pt i stedet.

H = 1080
W = 1920
scripted_fn = torch.jit.script(model, torch.randn(1, 3, H, W))
scripted_fn.save("model.pt")

Trinn 3: Lagre og last opp ML-modellartefakter til Amazon S3

Siden vi skal bruke SageMaker for ML-inferens, må vi laste opp modellvektene til en S3-bøtte. Vi kan gjøre dette ved å bruke følgende kommandoer eller ved å laste ned og ganske enkelt dra og slippe filen direkte inn i S3. Følgende kommandoer vil først komprimere gruppen av filer innenfor model.pt til en tarball og kopier modellvektene fra vår lokale maskin til S3-skuffen.

Merknader: For å kjøre følgende kommandoer, må du ha AWS Command Line Interface (AWS CLI) installert.

tar -czvf model.tar.gz model.pt
aws s3 cp model.tar.gz $MODEL_ARTIFACTS_FILE_NAME

Deretter kopierer vi inndatabildet vårt til S3. Nedenfor er hele S3-banen for bildet.

car_image_path = os.path.join(DATA_PATH, IMAGE_NAME)

Vi kan kopiere over dette bildet til S3 med en annen aws s3 cp-kommando.

aws s3 cp cars.jpg $car_image_path

Trinn 4: Bygg ML-modellslutningsskript

Nå skal vi gå over inngangspunktfilen vår, inference.py modul. Vi kan distribuere en PyTorch-modell trent utenfor SageMaker ved å bruke PyTorchModel-klassen. Først instansierer vi PyTorchModelZoo-objektet. Deretter vil vi konstruere en inference.py entrypoint-fil for å utføre ML-inferens ved hjelp av SageMaker batch-transformasjon på eksempeldata som er vert i Amazon S3.

Forstå PyTorchModel-objektet

De PyTorchModel klasse i SageMaker Python API lar oss utføre ML-inferens ved å bruke vår nedlastede modellartefakt.

For å starte PyTorchModel-klassen, må vi forstå følgende inngangsparametere:

• name: Modell navn; vi anbefaler å bruke enten modellnavnet + dato klokkeslett, eller en tilfeldig streng + dato klokkeslett for unikhet.
• model_data: S3-URI-en til den pakkede ML-modellartefakten.
• entry_point: En brukerdefinert Python-fil som skal brukes av inferens Docker-bildet for å definere behandlere for innkommende forespørsler. Koden definerer modelllasting, inndataforbehandling, prediksjonslogikk og utdataetterbehandling.
• framework_version: Må settes til versjon 1.2 eller høyere for å aktivere automatisk PyTorch-modellompakking.
• source_dir: Katalogen til entry_point-filen.
• role: En IAM-rolle for å sende AWS-tjenesteforespørsler.
• image_uri: Bruk dette Amazon ECR Docker-beholderbildet som en base for ML-modellberegningsmiljøet.
• sagemaker_session: SageMaker-økten.
• py_version: Python-versjonen som skal brukes

Følgende kodebit instansierer PyTorchModel-klassen for å utføre inferens ved å bruke den forhåndstrente PyTorch-modellen:

model = PyTorchModel(
               name=RANDOM_STRING,
               model_data=MODEL_ARTIFACTS_FILE_NAME,
               entry_point=ENTRY_POINT_FILE_NAME,
               framework_version=FRAMEWORK_VERSION,
               role=SAGEMAKER_EXECUTION_ROLE_ARN,
               sagemaker_session=sagemaker_session,
               image_uri=IMAGE_URI,
        )

Forstå inngangspunktfilen (inference.py)

Entry_point-parameteren peker til en Python-fil med navnet inference.py. Dette inngangspunktet definerer modelllasting, inndataforbehandling, prediksjonslogikk og utdataetterbehandling. Den supplerer ML-modellens serveringskode i den forhåndsbygde PyTorch SageMaker Deep Learning Container bilde.

Inference.py vil inneholde følgende funksjoner. I vårt eksempel implementerer vi model_fn, input_fn, predict_fn og output_fn funksjoner for å overstyre standard PyTorch-inferensbehandler.

1. model_fn: Tar inn en katalog som inneholder statiske modellsjekkpunkter i inferensbildet. Åpner og laster modellen fra en spesifisert bane og returnerer en PyTorch-modell.
2. input_fn: Tar inn nyttelasten til den innkommende forespørselen (request_body) og innholdstypen til en innkommende forespørsel (request_content_type) som input. Håndterer dataavkoding. Denne funksjonen må justeres for hvilken input modellen forventer.
3. predict_fn: Kaller en modell på data deserialisert i input_fn. Utfører prediksjon på det deserialiserte objektet med den innlastede ML-modellen.
4. output_fn: Serialiserer prediksjonsresultatet til ønsket responsinnholdstype. Konverterer spådommer hentet fra predict_fn-funksjonen til JSON-, CSV- eller NPY-formater.

Trinn 5: Lansering av en SageMaker batch-transformeringsjobb

For dette eksemplet vil vi oppnå ML-slutningsresultater gjennom en SageMaker batch-transformeringsjobb. Batch-transformeringsjobber er mest nyttige når vi ønsker å få slutninger fra datasett én gang, uten behov for et vedvarende endepunkt. Vi instansierer en sagemaker.transformator.Transformator objekt for å lage og samhandle med SageMaker batch-transformeringsjobber.

transformer = model.transformer(instance_type=INSTANCE_TYPE, 
                                instance_count=INSTANCE_COUNT
                                )
transformer.transform(data=DATA_PATH,
                      data_type="S3Prefix",
                      content_type="application/x-image",
                      wait=True
                      )

Se dokumentasjonen for å opprette en batch-transformeringsjobb på Opprett TransformJob.

Trinn 6: Visualisering av testresultater

Når SageMaker batch-transformeringsjobben er ferdig, kan vi laste inn ML-inferensutgangene fra Amazon S3. For dette, naviger til AWS-administrasjonskonsoll og søk etter Amazon SageMaker. På venstre panel, under slutning, Se Batch-transformeringsjobber.

Etter å ha valgt Batchtransformasjon, se nettsiden som viser alle SageMaker batch-transformeringsjobber. Vi kan se fremdriften i vår siste jobbutførelse.

Først vil jobben ha statusen «pågår». Når det er gjort, se statusendringen til Fullført.

Når statusen er merket som fullført, kan vi klikke på jobben for å se resultatene. Denne nettsiden inneholder jobbsammendraget, inkludert konfigurasjoner av jobben vi nettopp utførte.

Under Konfigurasjon av utdata, vil vi se en S3-utgangsbane. Det er her vi finner vår ML-inferensutgang.

Velg S3-utgangsbanen og se en [image_name].[file_type].out-fil med våre utdata. Utdatafilen vår vil inneholde en liste over tilordninger. Eksempel utgang:

[
  {
    "boxes": [
      [
        214.32322692871094,
        192.18418884277344,
        830.3932495117188,
        521.6996459960938
      ],
      [
        235.6244354248047,
        301.3315734863281,
        253.6448516845703,
        312.3525695800781
      ],
      [
        183.92031860351562,
        291.7759704589844,
        207.28196716308594,
        312.1448669433594
      ],
    ],
    "labels": [
      3,
      3,
      9,
    ],
    "scores": [
      0.8823906183242798,
      0.7710548639297485,
      0.4969744384288788,
    ]
  }
]

For å visualisere disse spådommene leser vi først utgangsbanen fra transformatorobjektet vårt.

def get_output_from_s3(s3uri, file_name):
    parsed_url = urlparse(s3uri)
    bucket_name = parsed_url.netloc
    prefix = parsed_url.path[1:]
    s3 = boto3.resource('s3')
    obj = s3.Object(bucket_name, '{}/{}'.format(prefix, file_name))
    return obj.get()["Body"].read().decode('utf-8')
    
# Output path from Batch Transform job
output_path = transformer.output_path

# Get the output file from S3
predictions = get_output_from_s3(output_path, "car.jpg.out")

Deretter behandler vi denne utdatafilen og visualiserer spådommene våre. Nedenfor spesifiserer vi vår konfidensgrense. Vi får listen over klasser fra COCO datasett objektkartlegging. Under inferens krever modellen bare inputtensorene og returnerer de etterbehandlede prediksjonene som en Liste[Dict[Tensor]], en for hvert inngangsbilde. Feltene til Dict er som følger, der N er antall deteksjoner:

1. bokser (FloatTensor[N, 4]): de forutsagte boksene i [x1, y1, x2, y2] format, med 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, Hvor W er bredden på bildet og H er høyden på bildet
2. etiketter (Int64Tensor[N]): de forutsagte merkingene for hver deteksjon
3. score (Tensor[N]): prediksjonsskårene for hver deteksjon

For mer informasjon om utgangen, se PyTorch Faster R-CNN FPN-dokumentasjon.

Modellutgangen inneholder grensebokser med respektive konfidenspoeng. Vi kan optimere visningen av falske positiver ved å fjerne avgrensingsbokser som modellen ikke er sikker på. Følgende kodebiter behandler spådommene i utdatafilen og tegner avgrensende bokser på spådommene der poengsummen er over konfidensgrensen vår. Vi setter sannsynlighetsterskelen, CONF_THRESH, til 75 for dette eksemplet.

def procress_batch_transform_output(predictions):
    predictions = eval(predictions)
    for pred in predictions[1:]:
        pred = pred[0]
        boxes = np.array(pred["boxes"])
        labels = np.array(pred["labels"])
        scores = np.array(pred["scores"])

        scores_idx = scores >= CONF_THRESH
        boxes_meet = boxes[scores_idx, :]
        labels_meet = labels[scores_idx]
        scores_meet = scores[scores_idx]

        labels_str = [CLASSES[i] for i in labels_meet]
        
        # Return a tuple containing labels, label index, score, and bounding box
        processed_predictions =  list(zip(labels_str, labels_meet, scores_meet, boxes_meet))
        return processed_predictions
    
    
def visualize_batch_transform_output(input_image, processed_predictions):
    # read input image from computer
    img = read_image(input_image)
    for label, label_index, score, box in processed_predictions:
        label = label + ", score: " + str(round(score, 2))
        # draw bounding box and fill color
        box = torch.tensor(box)
        box = box.unsqueeze(0)
        img = draw_bounding_boxes(img, box, width=5,labels=[label], font_size=16)

    # transform this image to PIL image
    img = torchvision.transforms.ToPILImage()(img)

    # display output
    img.show()

# Process the predictions in the output file
processed_predictions = procress_batch_transform_output(predictions)
visualize_batch_transform_output("car.jpg", processed_predictions)

Til slutt visualiserer vi disse kartleggingene for å forstå produksjonen vår.

Merknader: hvis bildet ikke vises i notatboken, vennligst finn det i katalogtreet på venstre side av JupyterLab og åpne det derfra.

Kjører eksempelkoden

For et fullstendig fungerende eksempel, klone koden i amazon-sagemaker-eksempler GitHub og kjør cellene i create_pytorch_model_sagemaker.ipynb notisbok.

konklusjonen

I dette blogginnlegget viste vi et ende-til-ende eksempel på å utføre ML-inferens ved å bruke en objektdeteksjonsmodell fra PyTorch Model Zoo ved å bruke SageMaker batch-transformasjon. Vi dekket innlasting av Faster R-CNN-objektdeteksjonsmodellvektene, lagring av dem i en S3-bøtte, skriving av en inngangspunktfil og forståelse av nøkkelparametrene i PyTorchModel API. Til slutt implementerte vi modellen og utførte ML-modellslutning, visualiserte modellutdataene og lærte å tolke resultatene.

Om forfatterne

Dipika Khullar er ML-ingeniør i Amazon ML Solutions Lab. Hun hjelper kunder med å integrere ML-løsninger for å løse deres forretningsproblemer. Senest har hun bygget opplærings- og inferenspipelines for mediekunder og prediktive modeller for markedsføring.

Marcelo Aberle er en ML-ingeniør i AWS AI-organisasjonen. Han leder MLOps innsats ved Amazon ML Solutions Lab, hjelper kunder med å designe og implementere skalerbare ML-systemer. Hans oppgave er å veilede kunder på deres ML-reise for bedrifter og akselerere deres ML-vei til produksjon.

Ninad Kulkarni er en anvendt vitenskapsmann i Amazon ML Solutions Lab. Han hjelper kundene å ta i bruk ML og AI ved å bygge løsninger for å løse deres forretningsproblemer. Senest har han bygget prediktive modeller for sport-, bil- og mediekunder.

Yash Shah er Science Manager i Amazon ML Solutions Lab. Han og teamet hans av anvendte forskere og ML-ingeniører jobber med en rekke ML-brukssaker fra helsevesen, sport, bilindustri og produksjon.