빠른 시작¶

이 가이드는 RBLN SDK를 사용하여 RBLN NPU에서 딥러닝 모델을 실행하기 위한 워크플로우를 제공합니다.

RBLN SDK는 제품군에 따라 나뉘지 않는 단일 SDK로, Rebel100™과 ATOM™ 모두 같은 버전의 패키지를 설치합니다. 따라서 설치 및 설정 과정은 동일하며, 모델 컴파일 및 추론 과정만 제품군별로 조금씩 다릅니다. 이 가이드는 다음의 과정들을 포함하고 있습니다:

설정 및 설치
모델 컴파일 및 추론

1. 설정 및 설치¶

시스템 요구사항¶

Ubuntu 22.04 LTS(Debian bullseye) 이상
Python: 3.10–3.14
RBLN NPU가 장착된 시스템
RBLN 드라이버

이 튜토리얼은 위의 시스템 요구사항이 준비된 환경에서 테스트한다고 가정합니다. 다음과 같이 rbln-smi 명령어를 사용하여 RBLN 드라이버 설치 여부 및 RBLN NPU의 존재 여부를 확인할 수 있습니다:

$ rbln-smi
+-------------------------------------------------------------------------------------------------+
|                                 Device Information KMD ver: X.X.XX                              |
+-----+-----------+---------+---------------+------+---------+------+---------------------+-------+
| NPU |    Name   | Device  |   PCI BUS ID  | Temp |  Power  | Perf |  Memory(used/total) |  Util |
+-----+-----------+---------+---------------+------+---------+------+---------------------+-------+
| 0   | RBLN-CA25 | rbln0   |  0000:05:00.0 |  37C |  54.7W  |  P14 |    0.0B / 15.7GiB   |   0.0 |
| 1   |           | rbln1   |  0000:06:00.0 |  34C |         |  P14 |    0.0B / 15.7GiB   |   0.0 |
| 2   |           | rbln2   |  0000:07:00.0 |  28C |         |  P14 |    0.0B / 15.7GiB   |   0.0 |
| 3   |           | rbln3   |  0000:08:00.0 |  26C |         |  P14 |    0.0B / 15.7GiB   |   0.0 |
+-----+-----------+---------+---------------+------+---------+------+---------------------+-------+
+-------------------------------------------------------------------------------------------------+
|                                       Context Information                                       |
+-----+---------------------+--------------+-----+----------+------+---------------------+--------+
| NPU | Process             |     PID      | CTX | Priority | PTID |           Memalloc  | Status |
+-----+---------------------+--------------+-----+----------+------+---------------------+--------+
| N/A | N/A                 |     N/A      | N/A |   N/A    | N/A  |                N/A  |  N/A   |
+-----+---------------------+--------------+-----+----------+------+---------------------+--------+

RBLN SDK 설치¶

RBLN SDK는 .whl 패키지로 배포됩니다. rebel-compiler 설치를 위해 RBLN Portal 계정이 필요합니다.

$ pip install \
  --extra-index-url https://pypi.rbln.ai/simple \
  rebel-compiler==0.12.0
$ pip install \
  --extra-index-url https://wheels.vllm.ai/0.30.0/cpu \
  --extra-index-url https://pypi.rbln.ai/simple \
  --extra-index-url https://download.pytorch.org/whl/cpu \
  "vllm-rbln[kv-connectors]==0.12.0"

Note

위 명령으로 vllm-rbln과 optimum-rbln이 함께 설치되어, RBLN Optimum도 같은 단계에서 바로 사용할 수 있습니다.

2. 모델 컴파일 및 추론¶

RBLN SDK는 tensorflow, torch, transformers, diffusers와 같은 다양한 딥러닝 프레임워크로 구축된 모델을 곧바로 RBLN NPU에서 실행합니다. 사용할 수 있는 옵션은 제품군마다 다릅니다. 사용 중인 제품군의 탭에서 모델에 맞는 옵션을 고른 뒤 그 옵션의 단계만 진행하면 됩니다. 각 옵션은 처음부터 끝까지 따로 진행됩니다.

Rebel100™ATOM™

옵션	모델	SDK 구성 요소
옵션 1: vLLM 모델	OpenAI 호환 API로 서빙하는 대형 언어 모델	• RBLN Compiler(`rebel-compiler`) • RBLN vLLM(`vllm-rbln`)
옵션 2: HuggingFace 모델	`transformers` 모델	• RBLN Compiler(`rebel-compiler`) • RBLN Optimum(`optimum-rbln`)
옵션 3: 커스텀 PyTorch / TensorFlow 모델	직접 구축한 PyTorch 또는 TensorFlow 모델	• RBLN Compiler(`rebel-compiler`)

옵션 1: vLLM 모델¶

대형 언어 모델은 RBLN SDK 설치에서 설치한 RBLN vLLM(vllm-rbln)을 사용하여 배포할 수 있습니다. 이는 HuggingFace 모델 ID를 vllm serve에 전달하는 것만으로 간단히 진행할 수 있습니다. RBLN vLLM은 서버를 처음 시작할 때 모델을 RBLN NPU용으로 컴파일한 뒤, vLLM의 OpenAI 호환 API로 서빙합니다.

1. 서버 시작¶

다음 예제는 Mixture-of-Experts(MoE) 모델인 openai/gpt-oss-120b를 Rebel100™(RBLN-CR13) 1개에서 서빙합니다. --data-parallel-size 1은 모델을 하나의 RBLN NPU에서 실행하고, --model-impl vllm은 vLLM 네이티브 모델 경로로 모델을 불러옵니다:

vllm serve openai/gpt-oss-120b \
    --served-model-name gpt-oss-120b \
    --model-impl vllm \
    --data-parallel-size 1 \
    --quantization mxfp4 \
    --max-model-len 131072 \
    --block-size 1024 \
    --max-num-seqs 1

위 명령어의 --data-parallel-size, --quantization, --max-model-len, --block-size, --max-num-seqs 값은 컴파일된 모델에 고정되어 컴파일 후에는 바꿀 수 없으며, 이 중 하나라도 바꾸면 다음 시작 시 모델을 다시 컴파일합니다. RBLN vLLM은 컴파일된 모델을 캐시하므로, 같은 값으로 다시 시작하면 이전에 컴파일한 모델을 재사용합니다. 캐시 동작은 Compile Cache에 정리되어 있습니다. 이 모델의 구성은 gpt-oss-120b 레시피에서 확인할 수 있습니다. vLLM Recipes에서 더 많은 모델을 제공하고 있습니다.

2. 요청 전송¶

서버가 준비되면 vLLM의 OpenAI 호환 API로 요청을 보냅니다. model 필드에는 --served-model-name 값을 입력합니다:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
      "model": "gpt-oss-120b",
      "messages": [{"role": "user", "content": "Hello"}]
    }'

옵션 2: HuggingFace 모델¶

transformers 같은 HuggingFace 라이브러리로 제공된 모델은 HuggingFace API를 RBLN NPU에 맞게 확장한 optimum-rbln으로 컴파일하고 실행할 수 있습니다.

1. 모델 컴파일¶

다음 예제는 HuggingFace의 causal language model을 RBLN NPU에서 실행할 수 있게 해 주는 RBLNAutoModelForCausalLM을 사용하여 meta-llama/Llama-3.2-3B-Instruct 모델을 Rebel100™ 1개로 컴파일하는 방법을 보여줍니다. 모델을 따로 생성하거나 가져올 필요 없이, RBLN Optimum API의 from_pretrained()에 HuggingFace 모델 ID와 export=True를 전달하면 모델을 불러오는 동시에 컴파일합니다:

import os

from optimum.rbln import RBLNAutoModelForCausalLM

model_id = "meta-llama/Llama-3.2-3B-Instruct"

# Compile and export
model = RBLNAutoModelForCausalLM.from_pretrained(
    model_id=model_id,
    export=True,  # export a PyTorch model to an RBLN model with optimum
    rbln_batch_size=1,
    rbln_max_seq_len=131_072,  # default "max_position_embeddings"
    rbln_num_devices=1,
    rbln_attn_impl="flash_attn",
    rbln_kvcache_partition_len=8_192,  # Length of KV cache partitions for flash attention
)

# Save compiled results to disk
model.save_pretrained(os.path.basename(model_id))

2. 추론 실행¶

추론 시에도 동일한 RBLNAutoModelForCausalLM 클래스를 사용합니다. 이전 단계의 컴파일과 달리 model_id에 컴파일된 모델이 저장된 로컬 경로를 입력하고 export 인자를 False로 설정합니다:

import os

from optimum.rbln import RBLNAutoModelForCausalLM
from transformers import AutoTokenizer

model_id = "meta-llama/Llama-3.2-3B-Instruct"
text = "Hey, are you conscious? Can you talk to me?"

# Load compiled model
model = RBLNAutoModelForCausalLM.from_pretrained(
    model_id=os.path.basename(model_id),
    export=False,
    rbln_device=0,
)

# Prepare inputs
tokenizer = AutoTokenizer.from_pretrained(model_id)
tokenizer.pad_token = tokenizer.eos_token
conversation = [{"role": "user", "content": text}]
text = tokenizer.apply_chat_template(
    conversation, add_generation_prompt=True, tokenize=False
)
inputs = tokenizer(text, return_tensors="pt", padding=True)

# Generate tokens
output_sequence = model.generate(
    inputs.input_ids,
    attention_mask=inputs.attention_mask,
    max_length=131_072,
)

input_len = inputs.input_ids.shape[-1]
generated_texts = tokenizer.decode(
    output_sequence[0][input_len:],
    skip_special_tokens=True,
    clean_up_tokenization_spaces=True,
)

# Show result
print(f"Result: {generated_texts}")

이 외에도 RBLN Model Zoo에서 더 많은 모델 예제를 제공하고 있습니다.

옵션 3: 커스텀 PyTorch / TensorFlow 모델¶

PyTorch나 TensorFlow로 직접 구축한 모델은 rebel-compiler로 컴파일하고 rebel.Runtime() API로 실행합니다.

1. 모델 생성 또는 가져오기¶

다음 예제는 간단한 PyTorch 모델을 정의합니다:

import torch
import torch.nn as nn


class SimpleConvBNRelu(nn.Module):
    def __init__(
        self, in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1
    ):
        super(SimpleConvBNRelu, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x


model = SimpleConvBNRelu()
print(model)

2. 모델 컴파일¶

rebel-compiler는 모델을 RBLN NPU에서 실행할 수 있는 형식으로 변환합니다. 아래 예제와 같은 PyTorch 모델은 rebel.compile_from_torch()를 사용하여 컴파일합니다:

import rebel
import torch
import torch.nn as nn


class SimpleConvBNRelu(nn.Module):
    def __init__(
        self, in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1
    ):
        super(SimpleConvBNRelu, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x


model = SimpleConvBNRelu().eval()

x = torch.rand(1, 3, 224, 224)

input_info = [
    ("x", list(x.shape), torch.float32),
]

compiled_model = rebel.compile_from_torch(model, input_info)
compiled_model.save("simple_conv_bn_relu.rbln")

PyTorch 모델은 torch.compile()과 rbln 백엔드로도 컴파일할 수 있습니다. 이 방법에서는 .rbln 파일과 아래 rebel.Runtime() 단계가 필요하지 않습니다. 컴파일된 모델을 호출하면 RBLN NPU용으로 컴파일한 뒤 실행합니다:

import rebel  # registers the "rbln" backend for torch.compile
import torch
import torch.nn as nn


class SimpleConvBNRelu(nn.Module):
    def __init__(
        self, in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1
    ):
        super(SimpleConvBNRelu, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x


torch.manual_seed(0)
model = SimpleConvBNRelu().eval()

compiled_model = torch.compile(
    model,
    backend="rbln",
    options={"cache_dir": "./.cache", "mode": "strict"},
    dynamic=False,
)

x = torch.rand(1, 3, 224, 224)

with torch.no_grad():
    result = compiled_model(x)  # first call: compiles, or loads from cache_dir
    result = compiled_model(x)  # warm path: runs the compiled model

print("--- Result ---")
print(result)

첫 호출: 모델을 컴파일하고 cache_dir에 저장합니다. cache_dir에 weight와 입력 shape이 같은 컴파일 결과가 이미 있으면 컴파일하지 않고 불러옵니다. torch.manual_seed(0)은 예제의 랜덤 weight를 실행마다 같게 유지하므로, 스크립트를 두 번째 실행할 때는 캐시를 사용합니다.
이후 호출: warm path를 탑니다. 입력 shape이 같으면 다시 컴파일하지 않고 컴파일된 모델을 RBLN NPU에서 실행합니다.

"mode": "strict"를 지정하면 rbln 백엔드가 그래프 컴파일에 실패할 때 에러를 냅니다. 지정하지 않으면 torch.compile()은 경고만 남기고 CPU의 eager 실행으로 fallback합니다. 전체 옵션은 torch.compile API를 참고하세요.

3. 추론 실행¶

컴파일된 모델을 rebel.Runtime() API로 불러와 RBLN NPU에서 실행합니다:

import rebel
import torch

x = torch.rand(1, 3, 224, 224)

module = rebel.Runtime("simple_conv_bn_relu.rbln")
inputs = x.numpy()
result = module.run(inputs)

print("--- Input ---")
print(inputs)
print("--- Result ---")
print(result)

옵션	모델	SDK 구성 요소
옵션 1: vLLM 모델	OpenAI 호환 API로 서빙하는 대형 언어 모델	• RBLN Compiler(`rebel-compiler`) • RBLN vLLM(`vllm-rbln`)
옵션 2: HuggingFace 모델	`transformers` 또는 `diffusers` 모델	• RBLN Compiler(`rebel-compiler`) • RBLN Optimum(`optimum-rbln`)
옵션 3: 커스텀 PyTorch / TensorFlow 모델	직접 구축한 PyTorch 또는 TensorFlow 모델	• RBLN Compiler(`rebel-compiler`)

옵션 1: vLLM 모델¶

대형 언어 모델은 RBLN SDK 설치에서 설치한 RBLN vLLM(vllm-rbln)을 사용하여 배포할 수 있습니다. 이는 HuggingFace 모델 ID를 vllm serve에 전달하는 것만으로 간단히 진행할 수 있습니다. RBLN vLLM은 서버를 처음 시작할 때 모델을 RBLN NPU용으로 컴파일한 뒤, vLLM의 OpenAI 호환 API로 서빙합니다.

1. 서버 시작¶

다음 예제는 dense 모델인 Qwen/Qwen3-0.6B를 ATOM™ 디바이스(RBLN-CA22 또는 RBLN-CA25) 1개에서 서빙합니다. --rbln-num-devices-per-local-rank는 모델을 tensor parallelism으로 몇 개의 NPU에 나누어 배치할지 정합니다:

vllm serve Qwen/Qwen3-0.6B \
    --model-impl transformers \
    --served-model-name Qwen3-0.6B \
    --rbln-num-devices-per-local-rank 1 \
    --max-model-len 40960 \
    --block-size 4096 \
    --max-num-seqs 1

ATOM™에서 vllm serve는 vllm implementation이 아닌 transformers(optimum)를 사용하여 모델을 실행합니다. 자세한 내용은 RBLN vLLM 문서의 transformers(optimum) 섹션에서 확인할 수 있습니다.

위 명령어의 --rbln-num-devices-per-local-rank, --max-model-len, --block-size, --max-num-seqs 값은 컴파일된 모델에 고정되어 컴파일 후에는 바꿀 수 없으며, 이 중 하나라도 바꾸면 다음 시작 시 모델을 다시 컴파일합니다. RBLN vLLM은 컴파일된 모델을 캐시하므로, 같은 값으로 다시 시작하면 이전에 컴파일한 모델을 재사용합니다. 캐시 동작은 Compile Cache에 정리되어 있습니다. 이 모델의 구성은 Qwen3-0.6B 레시피에서 확인할 수 있습니다. vLLM Recipes에서 더 많은 모델을 제공하고 있습니다.

2. 요청 전송¶

서버가 준비되면 vLLM의 OpenAI 호환 API로 요청을 보냅니다. model 필드에는 --served-model-name 값을 입력합니다:

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
      "model": "Qwen3-0.6B",
      "messages": [{"role": "user", "content": "Hello"}]
    }'

옵션 2: HuggingFace 모델¶

transformers나 diffusers 같은 HuggingFace 라이브러리로 제공된 모델은 HuggingFace API를 RBLN NPU에 맞게 확장한 optimum-rbln으로 컴파일하고 실행할 수 있습니다.

1. 모델 컴파일¶

다음 예제는 HuggingFace의 text-to-image 파이프라인을 RBLN NPU에서 실행할 수 있게 해 주는 RBLNAutoPipelineForText2Image를 사용하여 stabilityai/sdxl-turbo 모델을 컴파일하는 방법을 보여줍니다. 모델을 따로 생성하거나 가져올 필요 없이, RBLN Optimum API의 from_pretrained()에 HuggingFace 모델 ID와 export=True를 전달하면 모델을 불러오는 동시에 컴파일합니다:

import os

import torch
from optimum.rbln import RBLNAutoPipelineForText2Image

model_id = "stabilityai/sdxl-turbo"

# Compile and export
# As SDXL-turbo does not use guidance_scale, we disable it with rbln_guidance_scale=0.0
pipe = RBLNAutoPipelineForText2Image.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    export=True,  # export a PyTorch model to an RBLN model with optimum
    rbln_guidance_scale=0.0,
)

# Save compiled results to disk
pipe.save_pretrained(os.path.basename(model_id))

2. 추론 실행¶

추론 시에도 동일한 RBLNAutoPipelineForText2Image 클래스를 사용합니다. 이전 단계의 컴파일과 달리 model_id에 컴파일된 모델이 저장된 로컬 경로를 입력하고 export 인자를 False로 설정합니다:

import os

from optimum.rbln import RBLNAutoPipelineForText2Image

model_id = "stabilityai/sdxl-turbo"
prompt = "A cinematic shot of a baby racoon wearing an intricate italian priest robe."

# Load compiled model
pipe = RBLNAutoPipelineForText2Image.from_pretrained(
    model_id=os.path.basename(model_id),
    export=False,
)

# Generate image
image = pipe(prompt, num_inference_steps=1, guidance_scale=0.0).images[0]

# Save image result
image.save(f"{prompt}.png")

이 외에도 RBLN Model Zoo에서 더 많은 모델 예제를 제공하고 있습니다.

옵션 3: 커스텀 PyTorch / TensorFlow 모델¶

PyTorch나 TensorFlow로 직접 구축한 모델은 rebel-compiler로 컴파일하고 rebel.Runtime() API로 실행합니다.

1. 모델 생성 또는 가져오기¶

다음 예제는 간단한 PyTorch 모델을 정의합니다:

import torch
import torch.nn as nn


class SimpleConvBNRelu(nn.Module):
    def __init__(
        self, in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1
    ):
        super(SimpleConvBNRelu, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x


model = SimpleConvBNRelu()
print(model)

2. 모델 컴파일¶

rebel-compiler는 모델을 RBLN NPU에서 실행할 수 있는 형식으로 변환합니다. 아래 예제와 같은 PyTorch 모델은 rebel.compile_from_torch()를 사용하여 컴파일합니다:

import rebel
import torch
import torch.nn as nn


class SimpleConvBNRelu(nn.Module):
    def __init__(
        self, in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1
    ):
        super(SimpleConvBNRelu, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x


model = SimpleConvBNRelu().eval()

x = torch.rand(1, 3, 224, 224)

input_info = [
    ("x", list(x.shape), torch.float32),
]

compiled_model = rebel.compile_from_torch(model, input_info)
compiled_model.save("simple_conv_bn_relu.rbln")

PyTorch 모델은 torch.compile()과 rbln 백엔드로도 컴파일할 수 있습니다. 이 방법에서는 .rbln 파일과 아래 rebel.Runtime() 단계가 필요하지 않습니다. 컴파일된 모델을 호출하면 RBLN NPU용으로 컴파일한 뒤 실행합니다:

import rebel  # registers the "rbln" backend for torch.compile
import torch
import torch.nn as nn


class SimpleConvBNRelu(nn.Module):
    def __init__(
        self, in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1
    ):
        super(SimpleConvBNRelu, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
        self.bn = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, x):
        x = self.conv(x)
        x = self.bn(x)
        x = self.relu(x)
        return x


torch.manual_seed(0)
model = SimpleConvBNRelu().eval()

compiled_model = torch.compile(
    model,
    backend="rbln",
    options={"cache_dir": "./.cache", "mode": "strict"},
    dynamic=False,
)

x = torch.rand(1, 3, 224, 224)

with torch.no_grad():
    result = compiled_model(x)  # first call: compiles, or loads from cache_dir
    result = compiled_model(x)  # warm path: runs the compiled model

print("--- Result ---")
print(result)

첫 호출: 모델을 컴파일하고 cache_dir에 저장합니다. cache_dir에 weight와 입력 shape이 같은 컴파일 결과가 이미 있으면 컴파일하지 않고 불러옵니다. torch.manual_seed(0)은 예제의 랜덤 weight를 실행마다 같게 유지하므로, 스크립트를 두 번째 실행할 때는 캐시를 사용합니다.
이후 호출: warm path를 탑니다. 입력 shape이 같으면 다시 컴파일하지 않고 컴파일된 모델을 RBLN NPU에서 실행합니다.

"mode": "strict"를 지정하면 rbln 백엔드가 그래프 컴파일에 실패할 때 에러를 냅니다. 지정하지 않으면 torch.compile()은 경고만 남기고 CPU의 eager 실행으로 fallback합니다. 전체 옵션은 torch.compile API를 참고하세요.

3. 추론 실행¶

컴파일된 모델을 rebel.Runtime() API로 불러와 RBLN NPU에서 실행합니다:

import rebel
import torch

x = torch.rand(1, 3, 224, 224)

module = rebel.Runtime("simple_conv_bn_relu.rbln")
inputs = x.numpy()
result = module.run(inputs)

print("--- Input ---")
print(inputs)
print("--- Result ---")
print(result)

모델 서빙 프레임워크¶

옵션 1의 모델은 이미 RBLN vLLM으로 서빙되고 있습니다. 옵션 2와 옵션 3에서 컴파일한 모델은 RBLN NPU를 지원하는 다음 모델 서빙 프레임워크 중 하나로 프로덕션 환경에 배포합니다. 구성과 배포 방법은 각 프레임워크 문서에 정리되어 있습니다.

RBLN vLLM – 대형 언어 모델을 위한 고성능 추론 엔진(자세한 내용은 RBLN vLLM Documentation 참조)
NVIDIA Triton Inference Server – 다중 모델, 다중 프레임워크 추론 엔진(자세한 내용은 NVIDIA Triton Inference Server Documentation 참조)
TorchServe – 프로덕션 환경에 바로 배포할 수 있는 PyTorch 모델을 구축, 배포 및 실행하기 위한 프레임워크(자세한 내용은 TorchServe Documentation 참조)