Skapa Amazon SageMaker-modeller med hjälp av PyTorch Model Zoo

Att implementera högkvalitativa, utbildade maskininlärningsmodeller (ML) för att utföra antingen batch- eller realtidsinferens är en viktig del av att ge kunderna värde. Emellertid kan ML-experimentprocessen vara tråkig – det finns många tillvägagångssätt som kräver en betydande tid att implementera. Det är därför förutbildade ML-modeller som de som finns i PyTorch Model Zoo är så hjälpsamma. Amazon SageMaker ger ett enhetligt gränssnitt för att experimentera med olika ML-modeller, och PyTorch Model Zoo låter oss enkelt byta ut våra modeller på ett standardiserat sätt.

Det här blogginlägget visar hur man utför ML-inferens med hjälp av en objektdetekteringsmodell från PyTorch Model Zoo inom SageMaker. Förutbildade ML-modeller från PyTorch Model Zoo är färdiga och kan enkelt användas som en del av ML-applikationer. Att ställa in dessa ML-modeller som en SageMaker-slutpunkt eller SageMaker Batch Transform jobb för online eller offline slutledning är lätt med stegen som beskrivs i det här blogginlägget. Vi kommer att använda en Snabbare R-CNN objektdetekteringsmodell för att förutsäga begränsningsrutor för fördefinierade objektklasser.

Vi går igenom ett exempel från början till slut, från att ladda ner vikterna för Faster R-CNN-objektdetekteringsmodellen till att spara dem till en Amazon Simple Storage Service (Amazon S3) bucket och att skriva en startpunktsfil och förstå nyckelparametrarna i PyTorchModel API. Slutligen kommer vi att distribuera ML-modellen, göra slutsatser om den med SageMaker Batch Transform, och inspektera ML-modellens utdata och lära oss hur man tolkar resultaten. Denna lösning kan appliceras på vilken annan förtränad modell som helst på PyTorch Model Zoo. För en lista över tillgängliga modeller, se PyTorch Model Zoo-dokumentation.

Lösningsöversikt

Det här blogginlägget kommer att gå igenom följande steg. För en fullständig fungerande version av alla steg, se create_pytorch_model_sagemaker.ipynb

• Steg 1: Installation
• Steg 2: Laddar en ML-modell från PyTorch Model Zoo
• Steg 3 Spara och ladda upp ML-modellartefakter till Amazon S3
• Steg 4: Bygg ML-modell slutledningsskript
• Steg 5: Starta ett SageMaker-batchtransformeringsjobb
• Steg 6: Visualisera resultat

Arkitektur diagram

Katalogstruktur struktur~~POS=HEADCOMP

Koden för den här bloggen finns i denna GitHub repository. Kodbasen innehåller allt vi behöver för att bygga ML-modellartefakter, starta transformationsjobbet och visualisera resultat.

Det här är arbetsflödet vi använder. Alla följande steg kommer att hänvisa till moduler i denna 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

Smakämnen sagemaker_torch_model_zoo mappen ska innehålla inference.py som en entrypoint-fil, och create_pytorch_model_sagemaker.ipynb för att ladda och spara modellvikterna, skapa ett SageMaker-modellobjekt och slutligen överföra det till ett SageMaker-batchtransformeringsjobb. För att ta med dina egna ML-modeller, ändra sökvägarna i avsnittet Steg 1: installation av notebook-datorn och ladda en ny modell i Steg 2: Ladda en ML-modell från PyTorch Model Zoo-delen. Resten av följande steg nedan förblir desamma.

Steg 1: Installation

IAM-roller

SageMaker utför operationer på infrastruktur som hanteras av SageMaker. SageMaker kan endast utföra åtgärder som är tillåtna enligt definitionen i den bärbara datorns medföljande IAM-exekveringsroll för SageMaker. För mer detaljerad dokumentation om att skapa IAM-roller och hantera IAM-behörigheter, se AWS SageMaker rolldokumentation. Vi kan skapa en ny roll, eller så kan vi få den SageMaker (Studio) anteckningsboks standardexekveringsroll genom att köra följande kodrader:

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

Ovanstående kod får SageMaker-exekveringsrollen för notebook-instansen. Detta är IAM-rollen som vi skapade för vår SageMaker- eller SageMaker Studio-anteckningsbokinstans.

Användarkonfigurerbara parametrar

Här är alla konfigurerbara parametrar som behövs för att bygga och lansera vårt SageMaker batchtransformeringsjobb:

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)

Steg 2: Laddar en ML-modell från PyTorch Model Zoo

Därefter specificerar vi en objektdetekteringsmodell från PyTorch Model Zoo och sparar dess ML-modellvikter. Vanligtvis sparar vi en PyTorch-modell med filtilläggen .pt eller .pth. Kodavsnittet nedan laddar ner en förtränad Faster R-CNN ResNet50 ML-modell från PyTorch Model Zoo:

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

SageMaker batchtransformering kräver som indata vissa modellvikter, så vi sparar den förtränade ML-modellen som model.pt. Om vi ​​vill ladda en anpassad modell kan vi spara modellvikterna från en annan PyTorch-modell som model.pt istället.

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

Steg 3: Spara och ladda upp ML-modellartefakter till Amazon S3

Eftersom vi kommer att använda SageMaker för ML-inferens, måste vi ladda upp modellvikterna till en S3-skopa. Vi kan göra detta med hjälp av följande kommandon eller genom att ladda ner och helt enkelt dra och släppa filen direkt till S3. Följande kommandon kommer först att komprimera gruppen av filer inom model.pt till en tarball och kopiera modellvikterna från vår lokala maskin till S3-skopan.

Anmärkningar: För att köra följande kommandon måste du ha AWS-kommandoradsgränssnitt (AWS CLI) installerad.

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

Därefter kopierar vi vår ingångsbild till S3. Nedan är den fullständiga S3-vägen för bilden.

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

Vi kan kopiera över den här bilden till S3 med ett annat aws s3 cp-kommando.

aws s3 cp cars.jpg $car_image_path

Steg 4: Bygg ML-modell slutledningsskript

Nu ska vi gå igenom vår entrypoint-fil, inference.py modul. Vi kan distribuera en PyTorch-modell som tränats utanför SageMaker med PyTorchModel-klassen. Först instansierar vi PyTorchModelZoo-objektet. Sedan kommer vi att konstruera en inference.py entrypoint-fil för att utföra ML-inferens med SageMaker batchtransformering på exempeldata som finns i Amazon S3.

Förstå PyTorchModel-objektet

Smakämnen PyTorchModel klass inom SageMaker Python API tillåter oss att utföra ML-inferens med hjälp av vår nedladdade modellartefakt.

För att initiera PyTorchModel-klassen måste vi förstå följande ingångsparametrar:

• name: Modellnamn; vi rekommenderar att du använder antingen modellnamnet + datumtid eller en slumpmässig sträng + datumtid för unikhet.
• model_data: S3 URI för den paketerade ML-modellartefakten.
• entry_point: En användardefinierad Python-fil som ska användas av inferens Docker-bilden för att definiera hanterare för inkommande förfrågningar. Koden definierar modellladdning, ingångsförbearbetning, prediktionslogik och utdataefterbearbetning.
• framework_version: Behöver ställas in på version 1.2 eller högre för att aktivera automatisk PyTorch-modellompackning.
• source_dir: Katalogen för entry_point-filen.
• role: En IAM-roll för att göra AWS-tjänstförfrågningar.
• image_uri: Använd denna Amazon ECR Docker-containerbild som bas för ML-modellens beräkningsmiljö.
• sagemaker_session: SageMaker-sessionen.
• py_version: Python-versionen som ska användas

Följande kodsnutt instansierar PyTorchModel-klassen för att utföra slutledning med den förtränade 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,
        )

Förstå entrypoint-filen (inference.py)

Parametern entry_point pekar på en Python-fil med namnet inference.py. Denna startpunkt definierar modellladdning, ingångsförbearbetning, prediktionslogik och utdataefterbearbetning. Det kompletterar ML-modellens serveringskod i den förbyggda PyTorch SageMaker Deep Learning Container bild.

Inference.py kommer att innehålla följande funktioner. I vårt exempel implementerar vi model_fn, input_fn, predict_fn och output_fn funktioner för att åsidosätta standard PyTorch slutledningshanterare.

1. model_fn: Tar in en katalog som innehåller statiska modellkontrollpunkter i slutledningsbilden. Öppnar och laddar modellen från en angiven sökväg och returnerar en PyTorch-modell.
2. input_fn: Tar in nyttolasten för den inkommande begäran (request_body) och innehållstypen för en inkommande begäran (request_content_type) som indata. Hanterar dataavkodning. Denna funktion måste justeras för vilken input modellen förväntar sig.
3. predict_fn: Anropar en modell på data deserialiserad i input_fn. Utför förutsägelse av det deserialiserade objektet med den laddade ML-modellen.
4. output_fn: Serialiserar förutsägelseresultatet till önskad typ av svarsinnehåll. Konverterar förutsägelser som erhålls från funktionen predict_fn till JSON-, CSV- eller NPY-format.

Steg 5: Starta ett SageMaker-batchtransformeringsjobb

För det här exemplet kommer vi att få ML-slutledningsresultat genom ett SageMaker-batchtransformeringsjobb. Batchtransformeringsjobb är mest användbara när vi vill få slutsatser från datauppsättningar en gång, utan behov av en beständig slutpunkt. Vi instansierar en sagemaker.transformator.Transformator objekt för att skapa och interagera med SageMaker batchtransformeringsjobb.

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 för att skapa ett batchtransformeringsjobb på Skapa TransformJob.

Steg 6: Visualisera testresultat

När SageMaker batchtransformeringsjobbet är klart kan vi ladda ML-inferensutgångarna från Amazon S3. För detta, navigera till AWS Management Console och sök efter Amazon SageMaker. På den vänstra panelen, under Slutledning, Se Batchomvandlingsjobb.

Efter att ha valt Batchtransformation, se webbsidan som listar alla SageMaker batchtransformeringsjobb. Vi kan se utvecklingen av vårt senaste uppdrag.

Först kommer jobbet att ha statusen "Pågår". När det är klart, se statusändringen till Slutförd.

När statusen är markerad som klar kan vi klicka på jobbet för att se resultatet. Den här webbsidan innehåller jobbsammanfattningen, inklusive konfigurationer av jobbet vi just utförde.

Enligt Konfiguration av utdata, kommer vi att se en S3-utgångsväg. Det är här vi hittar vår ML-inferensutgång.

Välj S3-utgångssökvägen och se en [image_name].[file_type].out-fil med våra utdata. Vår utdatafil kommer att innehålla en lista med mappningar. Exempel på utdata:

[
  {
    "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,
    ]
  }
]

För att visualisera dessa förutsägelser läser vi först utdatavägen från vårt transformatorobjekt.

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

Därefter bearbetar vi denna utdatafil och visualiserar våra förutsägelser. Nedan specificerar vi vår konfidensgräns. Vi får listan över klasser från COCO-datauppsättningsobjektmappning. Under slutledning kräver modellen endast ingångstensorerna och returnerar de efterbehandlade förutsägelserna som en List[Dict[Tensor]], en för varje ingångsbild. Fälten i Dict är som följer, där N är antalet upptäckter:

1. boxar (FloatTensor[N, 4]): de förutsagda boxarna i [x1, y1, x2, y2] format, med 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= HDär W är bildens bredd och H är bildens höjd
2. etiketter (Int64Tensor[N]): de förutsagda markörerna för varje detektion
3. poäng (Tensor[N]): förutsägelsepoängen för varje detektion

För mer information om utgången, se PyTorch Faster R-CNN FPN-dokumentation.

Modellutgången innehåller begränsningsrutor med respektive konfidenspoäng. Vi kan optimera visningen av falska positiva resultat genom att ta bort begränsningsrutor som modellen inte är säker på. Följande kodsnuttar bearbetar förutsägelserna i utdatafilen och ritar begränsningsrutor på förutsägelserna där poängen ligger över vår konfidensgräns. Vi sätter sannolikhetströskeln, CONF_THRESH, till 75 för detta exempel.

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)

Slutligen visualiserar vi dessa mappningar för att förstå vår produktion.

Anmärkningar: om bilden inte visas i din anteckningsbok, leta reda på den i katalogträdet på vänster sida av JupyterLab och öppna den därifrån.

Kör exempelkoden

För ett fullständigt fungerande exempel, klona koden i amazon-sagemaker-exempel GitHub och kör cellerna i create_pytorch_model_sagemaker.ipynb anteckningsbok.

Slutsats

I det här blogginlägget visade vi upp ett heltäckande exempel på att utföra ML-inferens med hjälp av en objektdetekteringsmodell från PyTorch Model Zoo med SageMaker batchtransform. Vi täckte inläsning av Faster R-CNN-objektdetekteringsmodellens vikter, lagring av dem i en S3-hink, skrivning av en startpunktsfil och förståelse av nyckelparametrarna i PyTorchModel API. Slutligen distribuerade vi modellen och utförde ML-modellinferens, visualiserade modellens utdata och lärde oss hur man tolkar resultaten.

Om författarna

Dipika Khullar är en ML-ingenjör i Amazon ML Solutions Lab. Hon hjälper kunder att integrera ML-lösningar för att lösa deras affärsproblem. Senast har hon byggt utbildnings- och slutledningspipelines för mediekunder och prediktiva modeller för marknadsföring.

Marcelo Aberle är en ML-ingenjör i AWS AI-organisationen. Han leder MLOps ansträngningar på Amazon ML Solutions Lab, hjälper kunder att designa och implementera skalbara ML-system. Hans uppdrag är att vägleda kunder på deras ML-resa för företag och påskynda deras ML-väg till produktion.

Ninad Kulkarni är en tillämpad vetenskapsman i Amazon ML Solutions Lab. Han hjälper kunder att ta till sig ML och AI genom att bygga lösningar för att lösa deras affärsproblem. Senast har han byggt prediktiva modeller för sport-, fordons- och mediakunder.

Yash Shah är Science Manager i Amazon ML Solutions Lab. Han och hans team av tillämpade forskare och ML-ingenjörer arbetar med en rad ML-användningsfall från hälsovård, sport, fordon och tillverkning.