Opret Amazon SageMaker-modeller ved hjælp af PyTorch Model Zoo

Implementering af trænede maskinlæringsmodeller (ML) af høj kvalitet til at udføre enten batch- eller realtidsslutning er en vigtig del af at bringe værdi til kunderne. Imidlertid kan ML-eksperimenteringsprocessen være kedelig - der er mange tilgange, der kræver en betydelig mængde tid at implementere. Det er derfor, fortrænede ML-modeller som dem, der findes i PyTorch Model Zoo er så hjælpsomme. Amazon SageMaker giver en samlet grænseflade til at eksperimentere med forskellige ML-modeller, og PyTorch Model Zoo giver os mulighed for nemt at bytte vores modeller på en standardiseret måde.

Dette blogindlæg demonstrerer, hvordan man udfører ML-inferens ved hjælp af en objektdetektionsmodel fra PyTorch Model Zoo i SageMaker. Foruddannede ML-modeller fra PyTorch Model Zoo er færdiglavede og kan nemt bruges som en del af ML-applikationer. Opsætning af disse ML-modeller som et SageMaker-slutpunkt eller SageMaker Batch Transform job til online eller offline slutning er let med de trin, der er skitseret i dette blogindlæg. Vi vil bruge en Hurtigere R-CNN objektdetektionsmodel til at forudsige afgrænsningskasser for foruddefinerede objektklasser.

Vi gennemgår et ende-til-ende eksempel, fra indlæsning af Faster R-CNN-objektdetektionsmodelvægtene til at gemme dem til en Amazon Simple Storage Service (Amazon S3) bucket, og til at skrive en entrypoint-fil og forstå nøgleparametrene i PyTorchModel API. Til sidst vil vi implementere ML-modellen, udføre slutninger om den ved hjælp af SageMaker Batch Transform, og inspicere ML-modellens output og lære at fortolke resultaterne. Denne løsning kan anvendes på enhver anden fortrænet model i PyTorch Model Zoo. For en liste over tilgængelige modeller, se PyTorch Model Zoo dokumentation.

Løsningsoversigt

Dette blogindlæg vil gennemgå de følgende trin. For en fuld fungerende version af alle trin, se create_pytorch_model_sagemaker.ipynb

• Trin 1: Opsætning
• Trin 2: Indlæsning af en ML-model fra PyTorch Model Zoo
• Trin 3 Gem og upload ML-modelartefakter til Amazon S3
• Trin 4: Opbygning af ML model inferens scripts
• Trin 5: Lancering af et SageMaker batch-transformationsjob
• Trin 6: Visualisering af resultater

Arkitektur diagram

mappestruktur

Koden til denne blog kan findes i denne GitHub repository. Kodebasen indeholder alt, hvad vi behøver for at bygge ML-modelartefakter, starte transformationsjobbet og visualisere resultater.

Det er den arbejdsgang, vi bruger. Alle de følgende trin vil referere til moduler i denne struktur.

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

sagemaker_torch_model_zoo mappe skal indeholde inference.py som en entrypoint-fil, og create_pytorch_model_sagemaker.ipynb for at indlæse og gemme modelvægtene, oprette et SageMaker-modelobjekt og til sidst overføre det til et SageMaker batch-transformationsjob. For at medbringe dine egne ML-modeller skal du ændre stierne i trin 1: opsætningssektionen på notebooken og indlæse en ny model i trin 2: Indlæsning af en ML-model fra PyTorch Model Zoo sektionen. Resten af ​​de følgende trin nedenfor forbliver de samme.

Trin 1: Opsætning

IAM roller

SageMaker udfører operationer på infrastruktur, der administreres af SageMaker. SageMaker kan kun udføre handlinger, der er tilladt som defineret i notebookens medfølgende IAM-udførelsesrolle for SageMaker. For en mere detaljeret dokumentation om oprettelse af IAM-roller og administration af IAM-tilladelser henvises til AWS SageMaker rolledokumentation. Vi kan skabe en ny rolle, eller vi kunne få den SageMaker (Studio) notesbogs standardudførelsesrolle ved at køre følgende kodelinjer:

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()

Ovenstående kode får SageMaker-udførelsesrollen for notebook-forekomsten. Dette er IAM-rollen, som vi oprettede for vores SageMaker- eller SageMaker Studio-notebook-instans.

Brugerkonfigurerbare parametre

Her er alle de konfigurerbare parametre, der er nødvendige for at bygge og lancere vores SageMaker batch-transformationsjob:

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)

Trin 2: Indlæsning af en ML-model fra PyTorch Model Zoo

Dernæst specificerer vi en objektdetektionsmodel fra PyTorch Model Zoo og gemmer dens ML-modelvægte. Typisk gemmer vi en PyTorch-model ved hjælp af filtypenavnene .pt eller .pth. Kodestykket nedenfor downloader en forudtrænet Faster R-CNN ResNet50 ML-model fra PyTorch Model Zoo:

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

SageMaker batchtransformation kræver som input nogle modelvægte, så vi gemmer den fortrænede ML-model som model.pt. Hvis vi vil indlæse en brugerdefineret model, kan vi i stedet gemme modelvægtene fra en anden PyTorch-model som model.pt.

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

Trin 3: Gem og upload ML-modelartefakter til Amazon S3

Da vi skal bruge SageMaker til ML-inferens, skal vi uploade modelvægtene til en S3-spand. Vi kan gøre dette ved at bruge følgende kommandoer eller ved at downloade og blot trække og slippe filen direkte ind i S3. Følgende kommandoer vil først komprimere gruppen af ​​filer indeni model.pt til en tarball og kopier modelvægtene fra vores lokale maskine til S3-spanden.

Bemærk: For at køre følgende kommandoer skal du have AWS Command Line Interface (AWS CLI) installeret.

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

Dernæst kopierer vi vores inputbillede over til S3. Nedenfor er den fulde S3-sti til billedet.

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

Vi kan kopiere dette billede over til S3 med en anden aws s3 cp-kommando.

aws s3 cp cars.jpg $car_image_path

Trin 4: Opbygning af ML model inferens scripts

Nu vil vi gennemgå vores entrypoint-fil, inference.py modul. Vi kan implementere en PyTorch-model, der er trænet uden for SageMaker, ved hjælp af PyTorchModel-klassen. Først instansierer vi PyTorchModelZoo-objektet. Derefter vil vi konstruere en inference.py entrypoint-fil til at udføre ML-inferens ved hjælp af SageMaker batch-transformation på eksempeldata hostet i Amazon S3.

Forståelse af PyTorchModel-objektet

PyTorchModel klasse i SageMaker Python API giver os mulighed for at udføre ML-inferens ved hjælp af vores downloadede modelartefakt.

For at starte PyTorchModel-klassen skal vi forstå følgende inputparametre:

• name: Modelnavn; vi anbefaler at bruge enten modelnavnet + dato klokkeslæt eller en tilfældig streng + dato klokkeslæt for unikhed.
• model_data: S3 URI'en for den pakkede ML-modelartefakt.
• entry_point: En brugerdefineret Python-fil, der skal bruges af inferens Docker-billedet til at definere handlere for indgående anmodninger. Koden definerer modelindlæsning, inputforbehandling, forudsigelseslogik og outputefterbehandling.
• framework_version: Skal indstilles til version 1.2 eller nyere for at aktivere automatisk PyTorch-modelompakning.
• source_dir: Biblioteket til entry_point-filen.
• role: En IAM-rolle til at lave AWS-serviceanmodninger.
• image_uri: Brug dette Amazon ECR Docker-containerbillede som en base for ML-modelberegningsmiljøet.
• sagemaker_session: SageMaker-sessionen.
• py_version: Python-versionen, der skal bruges

Følgende kodestykke instansierer PyTorchModel-klassen til at udføre inferens ved hjælp af den præ-trænede PyTorch-model:

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å entrypoint-filen (inference.py)

Entry_point-parameteren peger på en Python-fil med navnet inference.py. Dette indgangspunkt definerer modelindlæsning, inputforbehandling, forudsigelseslogik og outputefterbehandling. Det supplerer ML-modellens serveringskode i den præbyggede PyTorch SageMaker Deep Learning Container billede.

Inference.py vil indeholde følgende funktioner. I vores eksempel implementerer vi model_fn, input_fn, predict_fn , output_fn funktioner til at tilsidesætte standard PyTorch-inferenshåndtering.

1. model_fn: Indtager en mappe, der indeholder statiske modelkontrolpunkter i inferensbilledet. Åbner og indlæser modellen fra en specificeret sti og returnerer en PyTorch-model.
2. input_fn: Indtager nyttelasten af ​​den indkommende anmodning (request_body) og indholdstypen for en indgående anmodning (request_content_type) som input. Håndterer dataafkodning. Denne funktion skal justeres for, hvilket input modellen forventer.
3. predict_fn: Kalder en model på data deserialiseret i input_fn. Udfører forudsigelse på det deserialiserede objekt med den indlæste ML-model.
4. output_fn: Serialiserer forudsigelsesresultatet til den ønskede svarindholdstype. Konverterer forudsigelser opnået fra funktionen predict_fn til JSON-, CSV- eller NPY-formater.

Trin 5: Lancering af et SageMaker batch-transformationsjob

For dette eksempel vil vi opnå ML-slutningsresultater gennem et SageMaker batch-transformationsjob. Batch-transformationsjob er mest nyttige, når vi ønsker at opnå slutninger fra datasæt én gang uden behov for et vedvarende slutpunkt. Vi instansierer en sagemaker.transformer.Transformer objekt til at skabe og interagere med SageMaker batch-transformationsjob.

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 dokumentationen for oprettelse af et batchtransformationsjob på Opret TransformJob.

Trin 6: Visualisering af testresultater

Når SageMaker batchtransformationsjobbet er afsluttet, kan vi indlæse ML-inferensoutput fra Amazon S3. For dette skal du navigere til AWS Management Console og søg efter Amazon SageMaker. På venstre panel, under InferensSe Batch transformation job.

Efter at have valgt Batch transformation, se websiden med alle SageMaker batch transformationsjob. Vi kan se fremskridtene i vores seneste jobudførelse.

For det første vil jobbet have status "Igangværende". Når det er gjort, kan du se statusændringen til Fuldført.

Når status er markeret som afsluttet, kan vi klikke på jobbet for at se resultaterne. Denne webside indeholder joboversigten, inklusive konfigurationer af det job, vi lige har udført.

Under Konfiguration af outputdata, vil vi se en S3-outputsti. Det er her, vi finder vores ML-inferensoutput.

Vælg S3-outputstien og se en [image_name].[file_type].out-fil med vores outputdata. Vores outputfil vil indeholde en liste over kortlægninger. Eksempel output:

[
  {
    "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 at visualisere disse forudsigelser læser vi først outputstien fra vores transformerobjekt.

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")

Dernæst behandler vi denne outputfil og visualiserer vores forudsigelser. Nedenfor angiver vi vores tillidsgrænse. Vi får listen over klasser fra COCO datasæt objekt mapping. Under inferens kræver modellen kun inputtensorerne og returnerer de efterbehandlede forudsigelser som en Liste[Dict[Tensor]], en for hvert inputbillede. Felterne i Dict er som følger, hvor N er antallet af detektioner:

1. kasser (FloatTensor[N, 4]): de forudsagte kasser i [x1, y1, x2, y2] format med 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= HHvor W er bredden af ​​billedet og H er billedets højde
2. etiketter (Int64Tensor[N]): de forudsagte mærker for hver detektion
3. scoringer (Tensor[N]): forudsigelsesscorerne for hver detektion

For flere detaljer om output, se PyTorch Faster R-CNN FPN-dokumentation.

Modeloutputtet indeholder afgrænsningsfelter med respektive konfidensscore. Vi kan optimere visningen af ​​falske positiver ved at fjerne afgrænsningsfelter, som modellen ikke er sikker på. Følgende kodestykker behandler forudsigelserne i outputfilen og tegner afgrænsningsfelter på forudsigelserne, hvor scoren er over vores konfidensgrænse. Vi sætter sandsynlighedsgrænsen, CONF_THRESH, til 75 for dette eksempel.

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 sidst visualiserer vi disse kortlægninger for at forstå vores output.

Bemærk: hvis billedet ikke vises i din notesbog, skal du finde det i mappetræet i venstre side af JupyterLab og åbne det derfra.

Kørsel af eksempelkoden

For et fuldt fungerende eksempel skal du klone koden i amazon-sagemaker-eksempler GitHub og kør cellerne i create_pytorch_model_sagemaker.ipynb notesbog.

Konklusion

I dette blogindlæg viste vi et ende-til-ende eksempel på at udføre ML-inferens ved hjælp af en objektdetekteringsmodel fra PyTorch Model Zoo ved hjælp af SageMaker batch-transformation. Vi dækkede indlæsning af Faster R-CNN-objektdetektionsmodelvægtene, lagring af dem i en S3-bøtte, skrivning af en entrypoint-fil og forståelse af nøgleparametrene i PyTorchModel API. Til sidst implementerede vi modellen og udførte ML-modelinferens, visualiserede modeloutputtet og lærte at fortolke resultaterne.

Om forfatterne

Dipika Khullar er ML-ingeniør i Amazon ML Solutions Lab. Hun hjælper kunder med at integrere ML-løsninger for at løse deres forretningsproblemer. Senest har hun bygget trænings- og inferenspipelines til mediekunder og prædiktive modeller til markedsføring.

Marcelo Aberle er ML-ingeniør i AWS AI-organisationen. Han leder MLOps indsats på Amazon ML Solutions Lab, hjælper kunder med at designe og implementere skalerbare ML-systemer. Hans mission er at guide kunder på deres ML-rejse i virksomheden og fremskynde deres ML-vej til produktion.

Ninad Kulkarni er en anvendt videnskabsmand i Amazon ML Solutions Lab. Han hjælper kunder med at adoptere ML og AI ved at bygge løsninger til at løse deres forretningsproblemer. Senest har han bygget prædiktive modeller til sports-, bil- og mediekunder.

Yash Shah er Science Manager i Amazon ML Solutions Lab. Han og hans team af anvendte videnskabsmænd og ML-ingeniører arbejder på en række ML-brugssager fra sundhedspleje, sport, bilindustrien og fremstilling.