Crea modelli Amazon SageMaker utilizzando PyTorch Model Zoo

L'implementazione di modelli di machine learning (ML) addestrati e di alta qualità per eseguire l'inferenza in batch o in tempo reale è un elemento fondamentale per offrire valore ai clienti. Tuttavia, il processo di sperimentazione ML può essere noioso: ci sono molti approcci che richiedono una notevole quantità di tempo per essere implementati. Ecco perché i modelli ML pre-addestrati come quelli forniti nel Zoo modello PyTorch sono così utili. Amazon Sage Maker fornisce un'interfaccia unificata per sperimentare diversi modelli ML e PyTorch Model Zoo ci consente di scambiare facilmente i nostri modelli in modo standardizzato.

Questo post del blog mostra come eseguire l'inferenza ML utilizzando un modello di rilevamento degli oggetti da PyTorch Model Zoo all'interno di SageMaker. I modelli ML preaddestrati da PyTorch Model Zoo sono già pronti e possono essere facilmente utilizzati come parte di applicazioni ML. Configurazione di questi modelli ML come endpoint SageMaker o Trasformazione batch di SageMaker il lavoro per l'inferenza online o offline è facile con i passaggi descritti in questo post del blog. Useremo un R-CNN più veloce modello di rilevamento degli oggetti per prevedere i riquadri di delimitazione per le classi di oggetti predefinite.

Esaminiamo un esempio end-to-end, dal caricamento dei pesi del modello di rilevamento degli oggetti Faster R-CNN, al loro salvataggio in un Servizio di archiviazione semplice Amazon (Amazon S3) bucket e alla scrittura di un file del punto di ingresso e alla comprensione dei parametri chiave nell'API PyTorchModel. Infine, distribuiremo il modello ML, eseguiremo l'inferenza su di esso utilizzando SageMaker Batch Transform, esamineremo l'output del modello ML e impareremo come interpretare i risultati. Questa soluzione può essere applicata a qualsiasi altro modello preaddestrato in PyTorch Model Zoo. Per un elenco dei modelli disponibili, vedere il Documentazione di PyTorch Model Zoo.

Panoramica della soluzione

Questo post del blog illustrerà i seguenti passaggi. Per una versione completa funzionante di tutti i passaggi, vedere create_pytorch_model_sagemaker.ipynb

• Passaggio 1: configurazione
• Passaggio 2: caricamento di un modello ML da PyTorch Model Zoo
• Passaggio 3 Salvare e caricare gli artefatti del modello ML su Amazon S3
• Passaggio 4: creazione di script di inferenza del modello ML
• Passaggio 5: avvio di un processo di trasformazione batch di SageMaker
• Passaggio 6: visualizzazione dei risultati

Diagramma di architettura

struttura a directory

Il codice per questo blog può essere trovato in this Repository GitHub. La base di codice contiene tutto ciò di cui abbiamo bisogno per creare artefatti del modello ML, avviare il processo di trasformazione e visualizzare i risultati.

Questo è il flusso di lavoro che utilizziamo. Tutti i passaggi seguenti faranno riferimento ai moduli in questa struttura.

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

I sagemaker_torch_model_zoo cartella dovrebbe contenere inference.py come file del punto di ingresso e create_pytorch_model_sagemaker.ipynb per caricare e salvare i pesi del modello, creare un oggetto modello SageMaker e infine passarlo in un processo di trasformazione batch SageMaker. Per portare i tuoi modelli ML, modifica i percorsi nella sezione Passaggio 1: configurazione del notebook e carica un nuovo modello nella sezione Passaggio 2: Caricamento di un modello ML dalla sezione Zoo modello PyTorch. Il resto dei seguenti passaggi rimarrebbe lo stesso.

Passaggio 1: configurazione

Ruoli IAM

SageMaker esegue operazioni sull'infrastruttura gestita da SageMaker. SageMaker può eseguire solo azioni consentite come definito nel ruolo di esecuzione IAM associato al notebook per SageMaker. Per una documentazione più dettagliata sulla creazione di ruoli IAM e sulla gestione delle autorizzazioni IAM, fare riferimento a Documentazione sui ruoli di AWS SageMaker. Possiamo creare un nuovo ruolo o ottenere il Taccuino SageMaker (Studio).ruolo di esecuzione predefinito di eseguendo le seguenti righe di codice:

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

Il codice precedente ottiene il ruolo di esecuzione SageMaker per l'istanza notebook. Questo è il ruolo IAM che abbiamo creato per la nostra istanza notebook SageMaker o SageMaker Studio.

Parametri configurabili dall'utente

Di seguito sono riportati tutti i parametri configurabili necessari per la creazione e l'avvio del processo di trasformazione batch di 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)

Passaggio 2: caricamento di un modello ML da PyTorch Model Zoo

Successivamente, specifichiamo un modello di rilevamento degli oggetti da PyTorch Model Zoo e salviamo i pesi del modello ML. In genere, salviamo un modello PyTorch utilizzando le estensioni di file .pt o .pth. Lo snippet di codice seguente scarica un modello ML Faster R-CNN ResNet50 ML pre-addestrato dal PyTorch Model Zoo:

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

La trasformazione batch di SageMaker richiede come input alcuni pesi del modello, quindi salveremo il modello ML pre-addestrato come model.pt. Se vogliamo caricare un modello personalizzato, potremmo invece salvare i pesi del modello da un altro modello PyTorch come model.pt.

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

Passaggio 3: salvare e caricare gli artefatti del modello ML su Amazon S3

Poiché utilizzeremo SageMaker per l'inferenza ML, dobbiamo caricare i pesi del modello in un bucket S3. Possiamo farlo utilizzando i seguenti comandi o scaricando e semplicemente trascinando il file direttamente in S3. I seguenti comandi comprimeranno prima il gruppo di file all'interno model.pt in un tarball e copiare i pesi del modello dalla nostra macchina locale al bucket S3.

Note:: Per eseguire i seguenti comandi, è necessario disporre del file Interfaccia a riga di comando AWS (AWS CLI) installato.

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

Successivamente, copiamo la nostra immagine di input su S3. Di seguito è riportato il percorso S3 completo per l'immagine.

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

Possiamo copiare questa immagine su S3 con un altro comando aws s3 cp.

aws s3 cp cars.jpg $car_image_path

Passaggio 4: creazione di script di inferenza del modello ML

Ora esamineremo il nostro file del punto di ingresso, inference.py modulo. Possiamo distribuire un modello PyTorch addestrato al di fuori di SageMaker utilizzando la classe PyTorchModel. Innanzitutto, istanziamo l'oggetto PyTorchModelZoo. Quindi costruiremo un file del punto di ingresso inference.py per eseguire l'inferenza ML utilizzando la trasformazione batch di SageMaker su dati di esempio ospitati in Amazon S3.

Comprensione dell'oggetto PyTorchModel

I Modello PyTorch all'interno dell'API Python di SageMaker ci consente di eseguire l'inferenza ML utilizzando il nostro artefatto del modello scaricato.

Per avviare la classe PyTorchModel, dobbiamo comprendere i seguenti parametri di input:

• name: Nome del modello; si consiglia di utilizzare il nome del modello + la data e l'ora o una stringa casuale + la data e l'ora per l'univocità.
• model_data: l'URI S3 dell'artefatto del modello ML in pacchetto.
• entry_point: un file Python definito dall'utente che deve essere utilizzato dall'immagine Docker di inferenza per definire i gestori per le richieste in entrata. Il codice definisce il caricamento del modello, la pre-elaborazione dell'input, la logica di previsione e la post-elaborazione dell'output.
• framework_version: Deve essere impostato sulla versione 1.2 o successiva per abilitare il riconfezionamento automatico del modello PyTorch.
• source_dir: la directory del file entry_point.
• role: un ruolo IAM per effettuare richieste di servizio AWS.
• image_uri: utilizza questa immagine del container Docker di Amazon ECR come base per l'ambiente di calcolo del modello ML.
• sagemaker_session: la sessione SageMaker.
• py_version: la versione di Python da utilizzare

Il seguente frammento di codice crea un'istanza della classe PyTorchModel per eseguire l'inferenza utilizzando il modello PyTorch preaddestrato:

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

Comprensione del file del punto di ingresso (inference.py)

Il parametro entry_point punta a un file Python denominato inference.py. Questo punto di ingresso definisce il caricamento del modello, la pre-elaborazione dell'input, la logica di previsione e la post-elaborazione dell'output. Integra il codice di servizio del modello ML nel PyTorch predefinito Contenitore di apprendimento profondo SageMaker immagine.

Inference.py conterrà le seguenti funzioni. Nel nostro esempio, implementiamo il model_fn, input_fn, predict_fn ed output_fn funzioni per ignorare il gestore di inferenza PyTorch predefinito.

1. model_fn: accetta una directory contenente checkpoint del modello statico nell'immagine di inferenza. Apre e carica il modello da un percorso specificato e restituisce un modello PyTorch.
2. input_fn: accetta il payload della richiesta in arrivo (request_body) e il tipo di contenuto di una richiesta in arrivo (request_content_type) come input. Gestisce la decodifica dei dati. Questa funzione deve essere regolata per l'input che il modello si aspetta.
3. predict_fn: chiama un modello sui dati deserializzati in input_fn. Esegue la previsione sull'oggetto deserializzato con il modello ML caricato.
4. output_fn: serializza il risultato della stima nel tipo di contenuto della risposta desiderato. Converte le previsioni ottenute dalla funzione predict_fn nei formati JSON, CSV o NPY.

Passaggio 5: avvio di un processo di trasformazione batch di SageMaker

Per questo esempio, otterremo i risultati dell'inferenza ML tramite un processo di trasformazione batch di SageMaker. I processi di trasformazione in batch sono particolarmente utili quando vogliamo ottenere inferenze dai set di dati una volta, senza la necessità di un endpoint persistente. Istanziamo a sagemaker.transformer.Transformer oggetto per la creazione e l'interazione con i processi di trasformazione batch di 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 la documentazione per la creazione di un processo di trasformazione batch all'indirizzo Crea lavoro di trasformazione.

Passaggio 6: visualizzazione dei risultati

Una volta terminato il processo di trasformazione batch di SageMaker, possiamo caricare gli output di inferenza ML da Amazon S3. Per questo, vai al Console di gestione AWS e cerca Amazon SageMaker. Nel pannello di sinistra, sotto Inferenza, Vedere Processi di trasformazione in batch.

Dopo aver selezionato Trasformazione batch, vedere la pagina Web che elenca tutti i processi di trasformazione batch di SageMaker. Possiamo visualizzare lo stato di avanzamento della nostra esecuzione del lavoro più recente.

Innanzitutto, il lavoro avrà lo stato "In corso". Al termine, vedere lo stato cambiare in Completato.

Una volta che lo stato è contrassegnato come completato, possiamo fare clic sul lavoro per visualizzare i risultati. Questa pagina Web contiene il riepilogo del lavoro, incluse le configurazioni del lavoro che abbiamo appena eseguito.

Sotto Configurazione dei dati di uscita, vedremo un percorso di output S3. Qui è dove troveremo il nostro output di inferenza ML.

Seleziona il percorso di output S3 e visualizza un file [image_name].[file_type].out con i nostri dati di output. Il nostro file di output conterrà un elenco di mappature. Esempio di 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,
    ]
  }
]

Per visualizzare queste previsioni, leggiamo prima il percorso di output dal nostro oggetto trasformatore.

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

Successivamente, elaboriamo questo file di output e visualizziamo le nostre previsioni. Di seguito specifichiamo la nostra soglia di confidenza. Otteniamo l'elenco delle classi da Mappatura degli oggetti del set di dati COCO. Durante l'inferenza, il modello richiede solo i tensori di input e restituisce le previsioni post-elaborate come List[Dict[Tensor]], una per ogni immagine di input. I campi del Dict sono i seguenti, dove N è il numero di rilevamenti:

1. box (FloatTensor[N, 4]): i box previsti in [x1, y1, x2, y2] formato, con 0 <= x1 < x2 <= W and 0 <= y1 < y2 <= H, Dove W è la larghezza dell'immagine e H è l'altezza dell'immagine
2. etichette (Int64Tensor[N]): le etichette previste per ogni rilevamento
3. punteggi (Tensor[N]): i punteggi di previsione per ogni rilevamento

Per ulteriori dettagli sull'output, fare riferimento a Documentazione PyTorch Faster R-CNN FPN.

L'output del modello contiene riquadri di delimitazione con i rispettivi punteggi di affidabilità. Possiamo ottimizzare la visualizzazione dei falsi positivi rimuovendo i riquadri di delimitazione per i quali il modello non è sicuro. I seguenti frammenti di codice elaborano le previsioni nel file di output e disegnano riquadri di delimitazione sulle previsioni in cui il punteggio è superiore alla nostra soglia di confidenza. Impostiamo la soglia di probabilità, CONF_THRESH, a .75 per questo esempio.

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)

Infine, visualizziamo queste mappature per comprendere il nostro output.

Note:: se l'immagine non viene visualizzata nel tuo notebook, individuala nell'albero delle directory sul lato sinistro di JupyterLab e aprila da lì.

Esecuzione del codice di esempio

Per un esempio funzionante completo, clonare il codice nel file amazon-sagemaker-esempi GitHub ed eseguire le celle in create_pytorch_model_sagemaker.ipynb taccuino.

Conclusione

In questo post del blog, abbiamo presentato un esempio end-to-end di esecuzione dell'inferenza ML utilizzando un modello di rilevamento degli oggetti da PyTorch Model Zoo utilizzando la trasformazione batch di SageMaker. Abbiamo coperto il caricamento dei pesi del modello di rilevamento degli oggetti Faster R-CNN, il loro salvataggio in un bucket S3, la scrittura di un file del punto di ingresso e la comprensione dei parametri chiave nell'API PyTorchModel. Infine, abbiamo distribuito il modello ed eseguito l'inferenza del modello ML, visualizzato l'output del modello e appreso come interpretare i risultati.

Informazioni sugli autori

Dipika Khullar è un ingegnere ML nel Laboratorio di soluzioni Amazon ML. Aiuta i clienti a integrare le soluzioni ML per risolvere i loro problemi aziendali. Più di recente, ha creato pipeline di formazione e inferenza per i clienti dei media e modelli predittivi per il marketing.

Marcello Aberle è un ingegnere ML nell'organizzazione AWS AI. Sta guidando gli sforzi di MLOps presso il Laboratorio di soluzioni Amazon ML, aiutando i clienti a progettare e implementare sistemi ML scalabili. La sua missione è guidare i clienti nel loro percorso di ML aziendale e accelerare il loro percorso di ML verso la produzione.

Ninad Kulkarni è uno scienziato applicato nel Laboratorio di soluzioni Amazon ML. Aiuta i clienti ad adottare ML e AI creando soluzioni per affrontare i loro problemi aziendali. Più recentemente, ha creato modelli predittivi per clienti sportivi, automobilistici e dei media.

Yash Shah è un Science Manager nel Laboratorio di soluzioni Amazon ML. Lui e il suo team di scienziati applicati e ingegneri ML lavorano su una gamma di casi d'uso ML da sanità, sport, automotive e produzione.