Creați modele Amazon SageMaker utilizând PyTorch Model Zoo

Implementarea modelelor de învățare automată (ML) de înaltă calitate, antrenate pentru a efectua inferențe în lot sau în timp real este o piesă esențială pentru a aduce valoare clienților. Cu toate acestea, procesul de experimentare ML poate fi plictisitor - există o mulțime de abordări care necesită o perioadă semnificativă de timp pentru implementare. De aceea modele ML pre-antrenate precum cele furnizate în PyTorch Model Zoo sunt atât de utile. Amazon SageMaker oferă o interfață unificată pentru a experimenta diferite modele ML, iar PyTorch Model Zoo ne permite să schimbăm cu ușurință modelele noastre într-un mod standardizat.

Această postare de blog demonstrează cum să efectuați inferențe ML folosind un model de detectare a obiectelor din PyTorch Model Zoo din SageMaker. Modelele ML pre-antrenate de la PyTorch Model Zoo sunt gata făcute și pot fi utilizate cu ușurință ca parte a aplicațiilor ML. Configurarea acestor modele ML ca punct final SageMaker sau SageMaker Batch Transform job pentru inferența online sau offline este ușor cu pașii descriși în această postare de blog. Vom folosi a R-CNN mai rapid model de detectare a obiectelor pentru a prezice casete de delimitare pentru clase de obiecte predefinite.

Trecem printr-un exemplu de la capăt la capăt, de la încărcarea greutăților modelului de detectare a obiectelor R-CNN Faster până la salvarea lor într-un Serviciul Amazon de stocare simplă (Amazon S3) bucket și să scrieți un fișier de intrare și să înțelegeți parametrii cheie din API-ul PyTorchModel. În cele din urmă, vom implementa modelul ML, vom efectua inferențe pe acesta folosind SageMaker Batch Transform și vom inspecta rezultatul modelului ML și vom învăța cum să interpretăm rezultatele. Această soluție poate fi aplicată oricărui alt model pre-antrenat de la PyTorch Model Zoo. Pentru o listă de modele disponibile, consultați Documentația PyTorch Model Zoo.

Prezentare generală a soluțiilor

Această postare de blog va parcurge următorii pași. Pentru o versiune completă de lucru a tuturor pașilor, consultați create_pytorch_model_sagemaker.ipynb

• Pasul 1: Configurare
• Pasul 2: Încărcarea unui model ML de la PyTorch Model Zoo
• Pasul 3 Salvați și încărcați artefactele modelului ML în Amazon S3
• Pasul 4: Construirea scripturilor de inferență pentru modelul ML
• Pasul 5: Lansarea unei sarcini de transformare batch SageMaker
• Pasul 6: Vizualizarea rezultatelor

Diagrama de arhitectură

Structura directorului

Codul pentru acest blog poate fi găsit în acesta GitHub depozit. Baza de cod conține tot ce avem nevoie pentru a construi artefacte de model ML, pentru a lansa jobul de transformare și pentru a vizualiza rezultatele.

Acesta este fluxul de lucru pe care îl folosim. Toți pașii următori se vor referi la modulele din această structură.

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 folderul ar trebui să conțină inference.py ca fișier de intrare și create_pytorch_model_sagemaker.ipynb pentru a încărca și a salva greutățile modelului, a crea un obiect model SageMaker și, în sfârșit, îl transferați într-o lucrare de transformare batch SageMaker. Pentru a vă aduce propriile modele ML, schimbați căile în secțiunea Pasul 1: configurare a notebook-ului și încărcați un model nou în Pasul 2: Încărcarea unui model ML din secțiunea PyTorch Model Zoo. Restul următorilor pași de mai jos vor rămâne neschimbați.

Pasul 1: Configurare

Roluri IAM

SageMaker efectuează operațiuni pe infrastructura care este gestionată de SageMaker. SageMaker poate efectua numai acțiuni permise așa cum sunt definite în rolul de execuție IAM al notebook-ului pentru SageMaker. Pentru o documentație mai detaliată despre crearea rolurilor IAM și gestionarea permisiunilor IAM, consultați Documentația rolurilor AWS SageMaker. Putem crea un nou rol sau putem obține Notebook SageMaker (Studio).rolul de execuție implicit al lui rulând următoarele linii de cod:

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

Codul de mai sus primește rolul de execuție SageMaker pentru instanța de notebook. Acesta este rolul IAM pe care l-am creat pentru instanța noastră de notebook SageMaker sau SageMaker Studio.

Parametri configurabili de utilizator

Iată toți parametrii configurabili necesari pentru construirea și lansarea lucrării noastre de transformare în loturi SageMaker:

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)

Pasul 2: Încărcarea unui model ML de la PyTorch Model Zoo

Apoi, specificăm un model de detectare a obiectelor din PyTorch Model Zoo și salvăm greutățile modelului ML. De obicei, salvăm un model PyTorch folosind extensiile de fișiere .pt sau .pth. Fragmentul de cod de mai jos descarcă un model pre-antrenat Faster R-CNN ResNet50 ML de la PyTorch Model Zoo:

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

Transformarea batch SageMaker necesită ca intrare câteva greutăți de model, așa că vom salva modelul ML pre-antrenat ca model.pt. Dacă dorim să încărcăm un model personalizat, am putea salva greutățile modelului dintr-un alt model PyTorch ca model.pt.

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

Pasul 3: Salvați și încărcați artefactele modelului ML în Amazon S3

Deoarece vom folosi SageMaker pentru inferența ML, trebuie să încărcăm greutățile modelului într-o găleată S3. Putem face acest lucru folosind următoarele comenzi sau prin descărcarea și pur și simplu tragerea și plasarea fișierului direct în S3. Următoarele comenzi vor comprima mai întâi grupul de fișiere din interior model.pt într-un tarball și copiați greutățile modelului de pe mașina noastră locală în găleată S3.

notițe: Pentru a rula următoarele comenzi, trebuie să aveți Interfață linie de comandă AWS (AWS CLI) instalat.

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

Apoi, copiem imaginea noastră de intrare în S3. Mai jos este calea S3 completă pentru imagine.

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

Putem copia această imagine în S3 cu o altă comandă aws s3 cp.

aws s3 cp cars.jpg $car_image_path

Pasul 4: Construirea scripturilor de inferență pentru modelul ML

Acum vom trece peste fișierul nostru de intrare, inference.py modul. Putem implementa un model PyTorch antrenat în afara SageMaker folosind clasa PyTorchModel. Mai întâi, instanțiem obiectul PyTorchModelZoo. Apoi vom construi un fișier de intrare inference.py pentru a efectua inferențe ML folosind transformarea batch SageMaker pe date eșantion găzduite în Amazon S3.

Înțelegerea obiectului PyTorchModel

PyTorchModel clasa din API-ul SageMaker Python ne permite să efectuăm inferențe ML folosind artefactul modelului nostru descărcat.

Pentru a iniția clasa PyTorchModel, trebuie să înțelegem următorii parametri de intrare:

• name: Numele modelului; vă recomandăm să folosiți fie numele modelului + data oră, fie un șir aleatoriu + data oră pentru unicitate.
• model_data: URI-ul S3 al artefactului model ML împachetat.
• entry_point: Un fișier Python definit de utilizator pentru a fi utilizat de imaginea Docker de inferență pentru a defini handlere pentru cererile primite. Codul definește încărcarea modelului, preprocesarea intrării, logica de predicție și post-procesarea ieșirii.
• framework_version: Trebuie setat la versiunea 1.2 sau mai mare pentru a activa reambalarea automată a modelului PyTorch.
• source_dir: directorul fișierului punct_de intrare.
• role: un rol IAM pentru a face solicitări de servicii AWS.
• image_uri: Utilizați această imagine de container Amazon ECR Docker ca bază pentru mediul de calcul al modelului ML.
• sagemaker_session: Sesiunea SageMaker.
• py_version: Versiunea Python care trebuie utilizată

Următorul fragment de cod instanțiază clasa PyTorchModel pentru a efectua inferențe folosind modelul PyTorch pre-antrenat:

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

Înțelegerea fișierului punct de intrare (inference.py)

Parametrul entry_point indică un fișier Python numit inference.py. Acest punct de intrare definește încărcarea modelului, preprocesarea intrării, logica de predicție și post-procesarea ieșirii. Acesta completează codul de servire a modelului ML în PyTorch predefinit Container de învățare profundă SageMaker imagine.

Inference.py va contine urmatoarele functii. În exemplul nostru, implementăm model_fn, input_fn, predict_fn și output_fn funcții pentru a anula handler implicit de inferență PyTorch.

1. model_fn: Preia un director care conține puncte de control static model în imaginea de inferență. Deschide și încarcă modelul dintr-o cale specificată și returnează un model PyTorch.
2. input_fn: Preia sarcina utilă a cererii primite (request_body) și tipul de conținut al unei cereri primite (request_content_type) ca intrare. Se ocupă de decodarea datelor. Această funcție trebuie să fie ajustată pentru ceea ce se așteaptă modelul.
3. predict_fn: Apelează un model pe date deserializate în input_fn. Efectuează predicția asupra obiectului deserializat cu modelul ML încărcat.
4. output_fn: Serializează rezultatul predicției în tipul de conținut de răspuns dorit. Convertește predicțiile obținute din funcția predict_fn în formate JSON, CSV sau NPY.

Pasul 5: Lansarea unei sarcini de transformare batch SageMaker

Pentru acest exemplu, vom obține rezultate de inferență ML printr-un job de transformare batch SageMaker. Lucrările de transformare în lot sunt cele mai utile atunci când dorim să obținem inferențe din seturi de date o singură dată, fără a fi nevoie de un punct final persistent. Instanțiăm a sagemaker.transformator.Transformator obiect pentru crearea și interacțiunea cu joburi de transformare batch SageMaker.

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
                      )

Consultați documentația pentru crearea unui job de transformare în lot la CreateTransformJob.

Pasul 6: Vizualizarea rezultatelor

Odată ce sarcina de transformare în loturi SageMaker se termină, putem încărca ieșirile de inferență ML din Amazon S3. Pentru aceasta, navigați la Consola de administrare AWS și căutați Amazon SageMaker. Pe panoul din stânga, sub deducție, A se vedea Locuri de muncă de transformare.

După selectare Transformarea lotului, consultați pagina web care listează toate lucrările de transformare în loturi SageMaker. Putem vedea progresul celei mai recente lucrări ale noastre.

În primul rând, jobul va avea statutul „În curs”. După ce ați terminat, vedeți schimbarea stării în Finalizat.

Odată ce starea este marcată ca finalizată, putem da clic pe lucrare pentru a vedea rezultatele. Această pagină web conține rezumatul jobului, inclusiv configurațiile jobului pe care tocmai l-am executat.

În Configurarea datelor de ieșire, vom vedea o cale de ieșire S3. Aici vom găsi rezultatul inferenței ML.

Selectați calea de ieșire S3 și vedeți un fișier [image_name].[file_type].out cu datele noastre de ieșire. Fișierul nostru de ieșire va conține o listă de mapări. Exemplu de ieșire:

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

Pentru a vizualiza aceste predicții, citim mai întâi calea de ieșire de la obiectul nostru transformator.

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

Apoi, procesăm acest fișier de ieșire și vizualizăm predicțiile noastre. Mai jos specificăm pragul nostru de încredere. Primim lista de clase de la Maparea obiectelor setului de date COCO. În timpul inferenței, modelul necesită doar tensorii de intrare și returnează predicțiile post-procesate ca List[Dict[Tensor]], câte una pentru fiecare imagine de intrare. Câmpurile Dict-ului sunt după cum urmează, unde N este numărul de detecții:

1. casete (FloatTensor[N, 4]): casetele prezise în [x1, y1, x2, y2] format, cu 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, În cazul în care W este lățimea imaginii și H este înălțimea imaginii
2. etichete (Int64Tensor[N]): etichetele prezise pentru fiecare detectie
3. scoruri (Tensor[N]): scorurile de predicție pentru fiecare detecție

Pentru mai multe detalii despre ieșire, consultați PyTorch Faster R-CNN FPN Documentație.

Ieșirea modelului conține casete de delimitare cu scorurile de încredere respective. Putem optimiza afișarea fals pozitive prin eliminarea casetelor de delimitare pentru care modelul nu este sigur. Următoarele fragmente de cod procesează predicțiile din fișierul de ieșire și desenează casete de delimitare pentru predicțiile în care scorul este peste pragul nostru de încredere. Stabilim pragul de probabilitate, CONF_THRESH, la .75 pentru acest exemplu.

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)

În cele din urmă, vizualizăm aceste mapări pentru a înțelege rezultatul nostru.

notițe: dacă imaginea nu se afișează în blocnotes, vă rugăm să o găsiți în arborele de directoare din partea stângă a JupyterLab și să o deschideți de acolo.

Rularea codului exemplu

Pentru un exemplu de lucru complet, clonați codul din fișierul amazon-sagemaker-examples GitHub și rulați celulele în create_pytorch_model_sagemaker.ipynb caiet.

Concluzie

În această postare pe blog, am prezentat un exemplu de la capăt la capăt al efectuării inferenței ML folosind un model de detectare a obiectelor din PyTorch Model Zoo folosind transformarea batch SageMaker. Am acoperit încărcarea greutăților modelului de detectare a obiectelor R-CNN Faster, salvarea lor într-o găleată S3, scrierea unui fișier de intrare și înțelegerea parametrilor cheie din API-ul PyTorchModel. În cele din urmă, am implementat modelul și am efectuat inferența modelului ML, am vizualizat rezultatul modelului și am învățat cum să interpretăm rezultatele.

Despre Autori

Dipika Khullar este inginer ML în Laboratorul Amazon ML Solutions. Ea îi ajută pe clienți să integreze soluții ML pentru a-și rezolva problemele de afaceri. Cel mai recent, ea a construit canale de instruire și inferență pentru clienții media și modele predictive pentru marketing.

Marcelo Aberle este inginer ML în organizația AWS AI. El conduce eforturile MLOps la Laboratorul Amazon ML Solutions, ajutând clienții să proiecteze și să implementeze sisteme ML scalabile. Misiunea lui este de a ghida clienții în călătoria lor ML pentru întreprinderi și de a-și accelera calea ML către producție.

Ninad Kulkarni este un om de știință aplicat în Laboratorul Amazon ML Solutions. El îi ajută pe clienți să adopte ML și AI prin construirea de soluții pentru a rezolva problemele lor de afaceri. Cel mai recent, el a construit modele predictive pentru clienții sport, auto și media.

Yash Shah este manager de știință în Laboratorul de soluții Amazon ML. El și echipa sa de oameni de știință aplicați și ingineri ML lucrează la o serie de cazuri de utilizare ML din domeniul sănătății, sport, auto și producție.