Inferenza GPU

La distribuzione del modello richiede un artifact modello memorizzato nel catalogo modelli e che il modello sia in stato attivo. L'artifact score.py del modello deve esporre una variabile del dispositivo GPU. La funzione load_model deve spostare il modello nel dispositivo GPU selezionato. Quindi, la funzione predict deve spostare i tensore di input nel dispositivo GPU. Dopo che l'inferenza viene calcolata sul dispositivo GPU, deve spostare di nuovo il tensore di uscita alla CPU prima di tornare dalla funzione.

L'esempio score.py riportato di seguito utilizza un dispositivo GPU disponibile per eseguire l'inferenza su un modello Resnet152 PyTorch.

import numpy as np
import os
import torch
from torch import nn
import io
from PIL import Image
import base64
from random import randint
  
  
Image.MAX_IMAGE_PIXELS = None
  
model_name = 'PyTorch_ResNet152.pth'
  
# get an available GPU device 
def get_torch_device():
    num_devices = torch.cuda.device_count()
    if num_devices == 0:
        return "cpu"
    if num_devices == 1:
        return "cuda:0"
    else:
        return f"cuda:{randint(0, num_devices-1)}"
  
print("Device selected for inference", get_torch_device())
device = torch.device(get_torch_device())
 
def load_model(model_file_name=model_name):
    """
    Loads model from the serialized format
  
    Returns
    -------
    model:  Pytorch model instance
    """
    print(f"Devcie {device}")
    model_dir = os.path.dirname(os.path.realpath(__file__))
    contents = os.listdir(model_dir)
    if model_file_name in contents:
        model.load_state_dict(torch.load(os.path.abspath(model_file_name)))    
        model = model.to(device)
        print(f"model saved to {model.get_device()}")
        return model
    else:
        raise FileNotFoundError(f'{model_file_name} is not found in model directory {model_dir}.')
 
def predict(data, model=load_model()):
    """
    Returns prediction given the model and data to predict
  
    Parameters
    ----------
    model: Model instance returned by load_model API
    data: Data format in json
  
    Returns
    -------
    predictions: Output from scoring server
        Format: {'prediction':output from model.predict method}
  
    """
  
    img_bytes = io.BytesIO(base64.b64decode(data.encode('utf-8')))
    image = Image.open(img_bytes).resize((224, 224))
    arr = np.array(image)
    X = torch.FloatTensor(np.transpose(arr, axes=(2, 0, 1))).unsqueeze(0)
    X = X.to(device)
    with torch.no_grad():
        Y = model(X).to("cpu")
        pred = torch.nn.functional.softmax(Y[0], dim=0).argmax().item()
    return {'prediction': pred}

MODEL_ARTIFACT_VERSION: '3.0'
MODEL_DEPLOYMENT:
  INFERENCE_CONDA_ENV:
    INFERENCE_ENV_PATH: oci://service-conda-packs@id19sfcrra6z/service_pack/gpu/PyTorch_1.10_for_GPU_on_Python_3.8/1.0/pytorch110_p38_gpu_v1
    INFERENCE_ENV_SLUG: pytorch_pack_v1
    INFERENCE_ENV_TYPE: data_science
    INFERENCE_PYTHON_VERSION: 3.8

Dopo aver creato un artifact modello GPU, creare una distribuzione modello e selezionare una delle forme GPU supportate.

La distribuzione del modello supporta il trasferimento del proprio contenitore come dipendenza runtime se si utilizza il server di inferenza. Quando si crea la distribuzione del modello, è necessario selezionare una delle forme GPU.

Quando si utilizza un server inferenza gestito dal servizio, le distribuzioni dei modelli caricano più repliche dei modelli nelle schede GPU disponibili per ottenere un throughput migliore. Il numero di repliche del modello viene calcolato in base a

• La dimensione del modello.

• Memoria disponibile sulla scheda GPU.

• Numero di schede GPU.

• Memorie centrali CPU logiche disponibili nella forma di computazione.

Ad esempio, il modello impiega 2 GB nella memoria e viene selezionata la forma VM.GPU2.1 che dispone di 1 scheda GPU con memoria GPU da 16 GB. La distribuzione del modello alloca una percentuale (circa il 70%) della memoria GPU per caricare i modelli e la memoria rimanente viene salvata per il calcolo runtime durante l'inferenza. La distribuzione del modello carica cinque repliche su una scheda GPU (16*(0.7) / 2 GB di dimensione del modello in memoria). Se sono disponibili 2 schede, un totale di 10 repliche del modello vengono caricate con 5 modelli in ogni scheda.

Con i file score.py generati automaticamente, la distribuzione delle repliche del modello nelle schede GPU si basa su un algoritmo casuale, che posiziona statisticamente un numero quasi uguale di repliche su ogni scheda. Tuttavia, è possibile modificare il numero di repliche utilizzando la variabile di ambiente dell'applicazione WEB_CONCURRENCY.

NVIDIA Triton Inference Server semplifica e standardizza l'inferenza AI consentendo AI team di distribuire, eseguire e ridimensionare modelli AI formati da qualsiasi framework su qualsiasi infrastruttura basata su GPU o CPU.

Impostare un server di inferenza NVIDIA Triton da utilizzare con le distribuzioni dei modelli.

Per abilitare l'inferenza GPU, config.pbtxt deve contenere KIND_GPU nel gruppo di istanze. La configurazione del gruppo di istanze può anche essere modificata per specificare il numero di repliche di un modello caricate sul dispositivo GPU