Inferencia de GPU

El despliegue del modelo requiere un artefacto de modelo almacenado en el catálogo de modelos y que el modelo esté en estado activo. score.py del artefacto de modelo debe exponer una variable de dispositivo de GPU. La función load_model debe mover el modelo al dispositivo de GPU seleccionado. A continuación, la función predict debe mover los tensores de entrada al dispositivo GPU. Después de calcular la inferencia en el dispositivo de GPU, debe mover el tensor de salida de nuevo a la CPU antes de volver de la función.

En el siguiente ejemplo de score.py se utiliza un dispositivo de GPU disponible para realizar una inferencia en un 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

Después de crear un artefacto de modelo de GPU, cree un despliegue de modelo y seleccione una de las unidades de GPU soportadas.

El despliegue de modelos soporta traer su propio contenedor como una dependencia de tiempo de ejecución si utiliza el servidor de inferencia. Debe seleccionar una de las unidades de GPU al crear el despliegue del modelo.

Al utilizar un servidor de inferencia gestionado por servicio, los despliegues de modelo cargan varias réplicas de modelo en las tarjetas GPU disponibles para lograr un mejor rendimiento. El número de réplicas de modelo se calcula en función de

• El tamaño del modelo.

• Memoria disponible en la tarjeta GPU.

• Número de tarjetas GPU.

• Núcleos de CPU lógicos disponibles en la unidad de computación.

Por ejemplo, el modelo tarda 2 GB en memoria y se selecciona la unidad VM.GPU2.1 que tiene 1 tarjeta GPU con 16 GB de memoria GPU. El despliegue del modelo asigna un porcentaje (alrededor del 70 %) de memoria de GPU para cargar modelos y la memoria restante se guarda para el cálculo en tiempo de ejecución durante la inferencia. El despliegue del modelo carga cinco réplicas en una tarjeta GPU (tamaño 16*(0.7) / 2 GB del modelo en memoria). Si hay 2 tarjetas disponibles, se cargan un total de 10 réplicas de modelos con 5 modelos en cada tarjeta.

Con los archivos score.py generados automáticamente, la distribución de réplicas de modelo a tarjetas de GPU se basa en un algoritmo aleatorio, que coloca estadísticamente un número casi igual de réplicas a cada tarjeta. Sin embargo, puede cambiar el número de réplicas mediante la variable de entorno de aplicación WEB_CONCURRENCY.

NVIDIA Triton Inference Server optimiza y estandariza la inferencia de IA al permitir a los equipos implementar, ejecutar y escalar modelos de IA entrenados desde cualquier marco en cualquier infraestructura basada en GPU o CPU.

Configure un servidor de inferencia NVIDIA Triton para utilizarlo con despliegues de modelos.

Para activar la inferencia de GPU, config.pbtxt debe contener KIND_GPU en el grupo de instancias. La configuración del grupo de instancias también se puede cambiar para especificar el número de réplicas de las cargas de un modelo en el dispositivo de GPU