GPU-Inferenz

Für das Modell-Deployment ist ein Modellartefakt erforderlich, das im Modellkatalog gespeichert ist. Außerdem muss sich das Modell in einem aktiven Status befinden. Die score.py des Modellartefakts muss eine GPU-Gerätevariable angeben. Die Funktion load_model muss das Modell auf das ausgewählte GPU-Gerät verschieben. Dann muss die Funktion predict die eingegebenen Tensoren auf das GPU-Gerät verschieben. Nachdem die Inferenz auf dem GPU-Gerät berechnet wurde, muss der Ausgabetensor wieder in die CPU verschoben werden, bevor er von der Funktion zurückkehrt.

Das folgende score.py-Beispiel verwendet ein verfügbares GPU-Gerät, um Inferenz für ein Resnet152 PyTorch-Modell auszuführen:

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

Nachdem ein GPU-Modellartefakt erstellt wurde, erstellen Sie ein Modell-Deployment, und wählen Sie eine der unterstützten GPU-Ausprägungen aus.

Das Modell-Deployment unterstützt das Bringen Ihres eigenen Containers als Laufzeitabhängigkeit, wenn Sie Ihren Inferenzserver verwenden. Beim Erstellen des Modell-Deployments müssen Sie eine der GPU-Ausprägungen auswählen.

Bei Verwendung eines von einem Service verwalteten Inferenzservers laden Modell-Deployments mehrere Modellreplikate auf verfügbare GPU-Karten, um einen besseren Durchsatz zu erzielen. Die Anzahl der Modellreplikate wird basierend auf

• Die Größe des Modells.

• Speicher auf der GPU-Karte verfügbar.

• Anzahl der GPU-Karten.

• Logische CPU-Cores, die auf der Compute-Ausprägung verfügbar sind.

Beispiel: Das Modell belegt 2 GB im Speicher, und die Ausprägung VM.GPU2.1 ist ausgewählt, die 1 GPU-Karte mit 16 GB GPU-Speicher enthält. Das Modell-Deployment weist einen Prozentsatz (rund 70%) des GPU-Speichers zum Laden von Modellen zu, und der verbleibende Speicher wird zur Laufzeitberechnung während der Inferenz gespeichert. Das Modell-Deployment lädt fünf Replikate auf einer GPU-Karte (16 * (0,7) / 2 GB Größe des Modells im Speicher). Wenn 2 Karten verfügbar sind, werden insgesamt 10 Modellreplikate mit 5 Modellen in jeder Karte geladen.

Bei automatisch generierten score.py-Dateien basiert die Verteilung von Modellreplikationen auf GPU-Karten auf einem zufälligen Algorithmus, der statistisch nahezu die gleiche Anzahl von Replikaten auf jeder Karte platziert. Sie können die Anzahl der Replikate jedoch mit der Anwendungsumgebungsvariablen WEB_CONCURRENCY ändern.

NVIDIA Triton Inference Server optimiert und standardisiert KI-Inferenz, indem Teams trainierte KI-Modelle aus jedem Framework auf einer beliebigen GPU- oder CPU-basierten Infrastruktur bereitstellen, ausführen und skalieren können.

NVIDIA Triton Inference Server einrichten für die Verwendung mit Modell-Deployments.

Um die GPU-Inferenz zu aktivieren, muss config.pbtxt KIND_GPU in der Instanzgruppe enthalten. Die Konfiguration der Instanzgruppe kann auch geändert werden, um die Anzahl der Replikate eines Modellladevorgangs auf das GPU-Gerät anzugeben