Inferência de GPU

A implantação de modelo exige um artefato de modelo armazenado no catálogo de modelos e que o modelo esteja em estado ativo. O score.py do artefato de modelo precisa expor uma variável de dispositivo de GPU. A função load_model deve mover o modelo para o dispositivo de GPU selecionado. Em seguida, a função predict deve mover os tensores de entrada para o dispositivo GPU. Depois que a inferência é calculada no dispositivo GPU, ele deve mover o tensor de saída de volta para a CPU antes de retornar da função.

O exemplo score.py a seguir usa um dispositivo GPU disponível para executar inferência em um modelo 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

Depois que um artefato de modelo de GPU for criado, você criará uma implantação de modelo e selecionará uma das formas de GPU suportadas.

A implantação de modelo suporta trazer seu próprio contêiner como uma dependência de runtime se você usar seu servidor de inferência. Selecione uma das formas de GPU ao criar a implantação de modelo.

Ao usar um servidor de inferência gerenciado por serviço, as implantações de modelo carregam várias réplicas de modelo para placas de GPU disponíveis para obter um melhor throughput. O número de réplicas de modelo é calculado com base em

• O tamanho do modelo.

• Memória disponível na placa GPU.

• Número de placas GPU.

• Núcleos de CPU lógicos disponíveis na forma de Computação.

Por exemplo, o modelo leva 2 GB na memória e a forma VM.GPU2.1 é selecionada com 1 placa de GPU com memória de GPU de 16 GB. A implantação de modelo aloca uma porcentagem (cerca de 70%) da memória GPU para carregar modelos e a memória restante é salva para computação de runtime durante a inferência. A implantação do modelo carrega cinco réplicas em uma placa de GPU (tamanho de 16*(0,7) / 2 GB do modelo na memória). Se 2 cartões estiverem disponíveis, um total de 10 réplicas de modelo serão carregadas com 5 modelos em cada cartão.

Com arquivos score.py gerados automaticamente, a distribuição de réplicas de modelo para placas de GPU é baseada em um algoritmo aleatório, que estatisticamente coloca um número quase igual de réplicas em cada placa. No entanto, você pode alterar o número de réplicas usando a variável de ambiente de aplicativo WEB_CONCURRENCY.

O NVIDIA Triton Inference Server simplifica e padroniza a inferência de IA, permitindo que as equipes implementem, executem e dimensionem modelos de IA treinados de qualquer estrutura em qualquer GPU ou infraestrutura baseada em CPU.

Configure um Servidor de Inferência de Tritão NVIDIA para usar com implantações de modelo.

Para ativar a inferência de GPU, o config.pbtxt deve conter KIND_GPU no grupo de instâncias. A configuração do grupo de instâncias também pode ser alterada para especificar o número de réplicas de carregamentos de um modelo no dispositivo de GPU