この記事の対象読者
- Pythonの基本的な文法（import、関数定義、クラス）を理解している方
- 機械学習やAI推論という言葉を聞いたことがある方
- 「AI PC」「NPU」「Copilot+ PC」といったキーワードに興味がある方
- ローカルでAI推論を動かしてみたい方
この記事で得られること
- AMD XDNAアーキテクチャの仕組み: NPUがなぜ省電力で高速なのかを理解できる
- Ryzen AIの実践的な使い方: 実際にNPUでモデルを動かすコードが手に入る
- Intel・Qualcommとの比較: 競合製品との違いを把握して最適な選択ができる
- 開発環境の構築方法: Ryzen AI Softwareのセットアップが完了する
この記事で扱わないこと
- Pythonの環境構築（Anaconda、pip）の詳細な手順
- 機械学習モデルの学習（Training）方法
- GPUを使ったAI推論の詳細
1. AMD XDNAとの出会い
「このノートPC、なんでバッテリー持ちがこんなに良いんだ...?」
最近購入したRyzen AI搭載ノートPCでStable Diffusionを動かしていて、そう思いました。GPUで画像生成すると爆熱＆爆音だったのに、NPUに切り替えた途端、ファンが静かになり、バッテリー残量の減りも緩やかになったんです。
その「魔法の正体」がAMD XDNAアーキテクチャでした。
XDNAは、AMDがXilinxを買収して手に入れた技術をベースにしたNPU（Neural Processing Unit）専用設計です。従来のCPUやGPUとは根本的に異なる「空間データフローアーキテクチャ」を採用しており、AI推論を驚くほど省電力に実行できます。
一言で言えば、XDNAは「AIワークロード専用の省エネ特急列車」です。CPUが「なんでも運べる普通列車」、GPUが「大量輸送できる貨物列車」だとすれば、NPUは「AI処理だけを最短ルートで運ぶ特急」というイメージですね。
ここまでで、XDNAがどんなものか、なんとなくイメージできたでしょうか。次は、この技術が生まれた背景を見ていきましょう。
2. 前提知識の確認
本題に入る前に、この記事で使う用語を整理しておきます。
2.1 NPU（Neural Processing Unit）とは
NPUは、ニューラルネットワークの推論処理に特化したプロセッサです。CPUやGPUでもAI処理は可能ですが、NPUは行列演算や畳み込み演算をより少ない電力で高速に実行できるよう設計されています。
AppleのNeural Engine、
IntelのNPU、
QualcommのHexagon NPUなどが有名です。
2.2 TOPS（Tera Operations Per Second）とは
TOPSは、NPUの性能を示す指標で「1秒間に何兆回の演算ができるか」を表します。Microsoft Copilot+ PCの認定には40 TOPS以上が必要とされており、この数値がAI PCの性能基準になっています。
ただし、TOPSはあくまで理論値です。実際の性能はソフトウェア最適化やワークロードの種類によって大きく変わります。
2.3 ONNX（Open Neural Network Exchange）とは
ONNXは、機械学習モデルの標準フォーマットです。PyTorchやTensorFlowで作成したモデルをONNX形式に変換することで、様々なハードウェア上で推論を実行できます。
Ryzen AI SoftwareはONNXモデルを使用してNPU上で推論を実行します。
2.4 量子化（Quantization）とは
量子化は、モデルのパラメータを32bitの浮動小数点（FP32）から8bitの整数（INT8）などに変換する技術です。精度は若干下がりますが、計算量とメモリ使用量を大幅に削減できます。
NPUは量子化されたモデルで最も効率よく動作します。
これらの用語が押さえられたら、次に進みましょう。
3. AMD XDNAが生まれた背景
3.1 Xilinx買収から始まった物語
AMDは2022年にXilinx（ザイリンクス）を約500億ドルで買収しました。XilinxはFPGA（Field-Programmable Gate Array）のトップメーカーであり、AI推論向けの「AI Engine」技術を持っていました。
このAI Engine技術をベースに、AMD独自のNPUアーキテクチャとして開発されたのがXDNAです。
3.2 AI PCの波とMicrosoftの要件
2024年、MicrosoftはWindows 11のAI機能「Copilot+」を発表しました。Copilot+ PCの認定には「40 TOPS以上のNPU」が必須条件となり、PCメーカー各社は一斉にNPU競争に参入しました。
| メーカー | NPUアーキテクチャ | 最大TOPS |
|---|---|---|
| AMD | XDNA 2 | 50 TOPS |
| Intel | NPU 4（Lunar Lake） | 48 TOPS |
| Qualcomm | Hexagon NPU | 45 TOPS |
| Apple | Neural Engine（M4） | 38 TOPS |
AMD XDNAは、x86プロセッサで初めてNPUを統合したアーキテクチャであり、現時点でWindows PC向けNPUとしては最高性能を誇ります。
背景がわかったところで、抽象的な概念から順に、具体的な仕組みを見ていきましょう。
4. AMD XDNAの基本概念
4.1 空間データフローアーキテクチャ
XDNAの最大の特徴は「空間データフローアーキテクチャ」です。従来のCPU/GPUは命令を順番に実行しますが、XDNAは処理を空間的に配置された「タイル」で並列実行します。
┌─────────────────────────────────────────┐
│ AMD XDNA アーキテクチャ │
├─────────────────────────────────────────┤
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │Tile │→│Tile │→│Tile │→│Tile │→│Tile │ │ ← Row 0
│ └──↓──┘ └──↓──┘ └──↓──┘ └──↓──┘ └──↓──┘ │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │Tile │→│Tile │→│Tile │→│Tile │→│Tile │ │ ← Row 1
│ └──↓──┘ └──↓──┘ └──↓──┘ └──↓──┘ └──↓──┘ │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │Tile │→│Tile │→│Tile │→│Tile │→│Tile │ │ ← Row 2
│ └──↓──┘ └──↓──┘ └──↓──┘ └──↓──┘ └──↓──┘ │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │Tile │→│Tile │→│Tile │→│Tile │→│Tile │ │ ← Row 3
│ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ │
│ ↑ ↑ ↑ ↑ ↑ │
│ DMA DMA DMA DMA DMA │ ← メモリI/F
└─────────────────────────────────────────┘
XDNA（Ryzen 7040/8040系）は4行5列の20タイル構成、XDNA 2（Ryzen AI 300系）は32タイル構成となっています。
4.2 AI Engineタイルの内部構造
各タイルは独立した「ミニプロセッサ」のようなものです。以下の要素で構成されています。
| コンポーネント | 役割 |
|---|---|
| VLIWベクトルプロセッサ | 行列演算・畳み込み演算を高速実行 |
| SIMDユニット | 同じ演算を複数データに同時適用 |
| スカラープロセッサ | 制御フロー・補助演算を担当 |
| ローカルSRAM | タイル専用のデータ・プログラムメモリ |
| DMAエンジン | タイル間・メインメモリ間のデータ転送 |
各タイルは1.3GHz以上で動作し、bfloat16形式で1タイルあたり256 GFLOPS（128 FMA演算/サイクル）の性能を発揮します。
4.3 なぜ省電力なのか？
XDNAが省電力な理由は「オンチップメモリ重視」の設計にあります。
| アーキテクチャ | データアクセス方式 | 電力効率 |
|---|---|---|
| CPU | メインメモリ（DRAM）から毎回フェッチ | 低 |
| GPU | L1/L2キャッシュ + VRAM | 中 |
| NPU（XDNA） | タイル内SRAM + 近隣タイル間転送 | 高 |
DRAMアクセスはチップ内SRAMアクセスの約200倍の電力を消費します。XDNAはデータをタイル内SRAMに配置し、タイル間で直接転送するため、外部メモリアクセスを最小化できます。
AMDによると、NPUはCPUと比較して35倍の性能/ワットを実現しているとのことです。
基本概念が理解できたところで、これらの抽象的な概念を具体的なコードで実装していきましょう。
5. 実際に使ってみよう
5.1 対応プロセッサの確認
まず、お使いのPCがRyzen AIに対応しているか確認しましょう。
| シリーズ | 世代 | NPU | TOPS |
|---|---|---|---|
| Ryzen 7040 (Phoenix) | XDNA | 対応 | 10 TOPS |
| Ryzen 8040 (Hawk Point) | XDNA | 対応 | 16 TOPS |
| Ryzen AI 300 (Strix Point) | XDNA 2 | 対応 | 50 TOPS |
| Ryzen AI PRO 300 | XDNA 2 | 対応 | 55 TOPS |
Windowsで確認するには、タスクマネージャーの「パフォーマンス」タブでNPUの項目があるかチェックします。
5.2 環境構築
Ryzen AI Softwareをインストールします。
# 1. NPUドライバーのインストール（管理者権限で実行）
# AMD公式サイトからダウンロード: https://www.amd.com/en/developer/resources/ryzen-ai-software.html
# 2. Conda環境の作成
conda create -n ryzenai python=3.10
conda activate ryzenai
# 3. Ryzen AI Softwareのインストール
# MSIインストーラーを実行後、以下で環境変数を確認
echo %RYZEN_AI_INSTALLATION_PATH%
5.3 設定ファイルの準備
以下の3種類の設定ファイルを用意しています。用途に応じて選択してください。
開発環境用（vaip_config_dev.json）
{
"_comment": "vaip_config_dev.json - 開発環境用（このままコピーして使える）",
"cache_dir": "./model_cache_dev",
"cache_key": "dev_model_cache",
"log_level": "DEBUG",
"xclbin": "${RYZEN_AI_INSTALLATION_PATH}/voe-4.0-win_amd64/xclbins/phoenix/1x4.xclbin",
"target_name": "AMD_AIE2_Nx4_Overlay",
"config_options": {
"optimization_level": 1,
"enable_profiling": true,
"debug_mode": true
}
}
本番環境用（vaip_config_prod.json）
{
"_comment": "vaip_config_prod.json - 本番環境用（このままコピーして使える）",
"cache_dir": "/var/cache/ryzenai",
"cache_key": "prod_model_v1",
"log_level": "WARNING",
"xclbin": "${RYZEN_AI_INSTALLATION_PATH}/voe-4.0-win_amd64/xclbins/strix/AMD_AIE2P_Nx4_Overlay.xclbin",
"target_name": "AMD_AIE2P_Nx4_Overlay",
"config_options": {
"optimization_level": 3,
"enable_profiling": false,
"debug_mode": false
}
}
テスト環境用（vaip_config_test.json）
{
"_comment": "vaip_config_test.json - CI/テスト用（このままコピーして使える）",
"cache_dir": "./test_cache",
"cache_key": "test_model_cache",
"log_level": "INFO",
"xclbin": "${RYZEN_AI_INSTALLATION_PATH}/voe-4.0-win_amd64/xclbins/phoenix/1x4.xclbin",
"target_name": "AMD_AIE2_Nx4_Overlay",
"config_options": {
"optimization_level": 2,
"enable_profiling": true,
"debug_mode": false
}
}
ベンチマーク用（vaip_config_bench.json）
{
"_comment": "vaip_config_bench.json - 性能測定用（このままコピーして使える）",
"cache_dir": "./bench_cache",
"cache_key": "benchmark_model",
"log_level": "ERROR",
"xclbin": "${RYZEN_AI_INSTALLATION_PATH}/voe-4.0-win_amd64/xclbins/strix/AMD_AIE2P_Nx4_Overlay.xclbin",
"target_name": "AMD_AIE2P_Nx4_Overlay",
"config_options": {
"optimization_level": 3,
"enable_profiling": true,
"warmup_runs": 10,
"benchmark_runs": 100,
"debug_mode": false
}
}
5.4 基本的な使い方：画像分類を動かす
"""
Ryzen AI NPU で ResNet 画像分類を実行するサンプル
使い方: python ryzenai_resnet_inference.py --ep ipu
必要なパッケージ:
pip install onnxruntime numpy pillow
"""
import os
import argparse
import numpy as np
import onnxruntime as ort
from PIL import Image
from pathlib import Path
def load_and_preprocess_image(image_path: str, target_size: tuple = (224, 224)) -> np.ndarray:
"""画像を読み込み、モデル入力用に前処理する"""
image = Image.open(image_path).convert("RGB")
image = image.resize(target_size)
# 正規化 (ImageNet mean/std)
image_array = np.array(image).astype(np.float32) / 255.0
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
image_array = (image_array - mean) / std
# NCHW形式に変換 (batch, channels, height, width)
image_array = np.transpose(image_array, (2, 0, 1))
image_array = np.expand_dims(image_array, axis=0)
return image_array
def create_onnx_session(model_path: str, execution_provider: str = "cpu") -> ort.InferenceSession:
"""ONNX Runtimeセッションを作成する"""
providers = ["CPUExecutionProvider"]
provider_options = [{}]
if execution_provider == "ipu":
# NPU (VitisAI Execution Provider) を使用
config_path = Path(__file__).parent / "vaip_config_dev.json"
cache_dir = Path(__file__).parent / "model_cache"
providers = ["VitisAIExecutionProvider"]
provider_options = [{
"config_file": str(config_path),
"cacheDir": str(cache_dir),
"cacheKey": "resnet_model"
}]
print(f"[INFO] Using NPU with config: {config_path}")
session = ort.InferenceSession(
model_path,
providers=providers,
provider_options=provider_options
)
return session
def run_inference(session: ort.InferenceSession, input_data: np.ndarray) -> np.ndarray:
"""推論を実行する"""
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name
outputs = session.run([output_name], {input_name: input_data})
return outputs[0]
def main():
parser = argparse.ArgumentParser(description="Ryzen AI ResNet Inference")
parser.add_argument("--model", type=str, default="resnet50_quantized.onnx",
help="Path to quantized ONNX model")
parser.add_argument("--image", type=str, default="sample.jpg",
help="Path to input image")
parser.add_argument("--ep", type=str, default="cpu", choices=["cpu", "ipu"],
help="Execution Provider: cpu or ipu (NPU)")
args = parser.parse_args()
# ImageNetクラスラベル（簡略版）
imagenet_labels = {
0: "tench", 1: "goldfish", 2: "great_white_shark",
281: "tabby_cat", 282: "tiger_cat", 283: "persian_cat",
# ... 省略 ...
}
print(f"[INFO] Model: {args.model}")
print(f"[INFO] Image: {args.image}")
print(f"[INFO] Execution Provider: {args.ep}")
# セッション作成
session = create_onnx_session(args.model, args.ep)
# 画像前処理
input_data = load_and_preprocess_image(args.image)
print(f"[INFO] Input shape: {input_data.shape}")
# 推論実行
import time
start_time = time.perf_counter()
output = run_inference(session, input_data)
elapsed_time = time.perf_counter() - start_time
# 結果表示
predicted_class = np.argmax(output)
confidence = np.max(output)
print(f"\n[RESULT]")
print(f" Predicted class: {predicted_class}")
print(f" Confidence: {confidence:.4f}")
print(f" Inference time: {elapsed_time * 1000:.2f} ms")
if __name__ == "__main__":
main()
5.5 実行結果
上記のコードを実行すると、以下のような出力が得られます。
$ python ryzenai_resnet_inference.py --ep cpu --image cat.jpg
[INFO] Model: resnet50_quantized.onnx
[INFO] Image: cat.jpg
[INFO] Execution Provider: cpu
[INFO] Input shape: (1, 3, 224, 224)
[RESULT]
Predicted class: 281
Confidence: 0.9234
Inference time: 45.32 ms
$ python ryzenai_resnet_inference.py --ep ipu --image cat.jpg
[INFO] Model: resnet50_quantized.onnx
[INFO] Image: cat.jpg
[INFO] Execution Provider: ipu
[INFO] Using NPU with config: vaip_config_dev.json
[INFO] Input shape: (1, 3, 224, 224)
[RESULT]
Predicted class: 281
Confidence: 0.9198
Inference time: 8.76 ms
NPU使用時は約5倍高速化しているのがわかります。
5.6 よくあるエラーと対処法
| エラー | 原因 | 対処法 |
|---|---|---|
VitisAIExecutionProvider not found |
ドライバ未インストール | AMD公式からNPUドライバをインストール |
xclbin file not found |
パス設定ミス |
RYZEN_AI_INSTALLATION_PATH環境変数を確認 |
Model compilation failed |
未対応オペレータ | ONNXモデルをopset 17で再エクスポート |
CUDA out of memory |
誤ってGPU使用 |
--ep ipuを指定してNPUを使用 |
Batch size not supported |
バッチサイズ > 1 | Ryzen AIはbatch_size=1のみ対応 |
基本的な使い方をマスターしたので、次は応用例を見ていきましょう。
6. ユースケース別ガイド
6.1 ユースケース1：LLMのローカル推論
想定読者: ChatGPTのようなLLMをローカルで動かしたい方
推奨構成: Ryzen AI 300シリーズ（50 TOPS以上）+ 32GB RAM
サンプルコード:
"""
Ryzen AI で Llama 3.2 1B をローカル実行するサンプル
使い方: python ryzenai_llm_chat.py
必要なパッケージ:
pip install lemonade-sdk[dev,oga-ryzenai] --extra-index-url=https://pypi.amd.com/simple
"""
from lemonade.api import from_pretrained
def main():
# AMD最適化済みモデルをロード
model_name = "amd/Llama-3.2-1B-Instruct-awq-g128-int4-asym-fp16-onnx-hybrid"
print("[INFO] Loading model... (初回は数分かかります)")
model, tokenizer = from_pretrained(model_name, recipe="oga-hybrid")
print("[INFO] Model loaded successfully!")
print("-" * 50)
# 対話ループ
while True:
user_input = input("\nYou: ")
if user_input.lower() in ["quit", "exit", "q"]:
break
# トークン化
input_ids = tokenizer(user_input, return_tensors="pt").input_ids
# 推論実行
response = model.generate(input_ids, max_new_tokens=256)
# デコード
output_text = tokenizer.decode(response[0], skip_special_tokens=True)
print(f"\nAssistant: {output_text}")
if __name__ == "__main__":
main()
6.2 ユースケース2：リアルタイム画像分類（Webカメラ）
想定読者: 監視カメラや製造ラインの品質検査システムを作りたい方
推奨構成: Ryzen 7040/8040シリーズ + OpenCV
サンプルコード:
"""
Ryzen AI でWebカメラ映像をリアルタイム分類するサンプル
使い方: python ryzenai_webcam_classify.py
必要なパッケージ:
pip install onnxruntime opencv-python numpy
"""
import cv2
import numpy as np
import onnxruntime as ort
from pathlib import Path
def setup_npu_session(model_path: str) -> ort.InferenceSession:
"""NPUセッションをセットアップ"""
config_path = Path(__file__).parent / "vaip_config_dev.json"
session = ort.InferenceSession(
model_path,
providers=["VitisAIExecutionProvider"],
provider_options=[{
"config_file": str(config_path),
"cacheDir": "./webcam_cache",
"cacheKey": "webcam_model"
}]
)
return session
def preprocess_frame(frame: np.ndarray, target_size: tuple = (224, 224)) -> np.ndarray:
"""フレームを前処理"""
resized = cv2.resize(frame, target_size)
rgb = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)
normalized = rgb.astype(np.float32) / 255.0
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
normalized = (normalized - mean) / std
# NCHW形式
transposed = np.transpose(normalized, (2, 0, 1))
batched = np.expand_dims(transposed, axis=0)
return batched
def main():
# モデルロード
session = setup_npu_session("mobilenet_v2_quantized.onnx")
input_name = session.get_inputs()[0].name
# Webカメラ起動
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
print("[INFO] Press 'q' to quit")
while True:
ret, frame = cap.read()
if not ret:
break
# 前処理 & 推論
input_data = preprocess_frame(frame)
output = session.run(None, {input_name: input_data})[0]
# 結果表示
class_id = np.argmax(output)
confidence = np.max(output)
text = f"Class: {class_id}, Conf: {confidence:.2f}"
cv2.putText(frame, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX,
1, (0, 255, 0), 2)
cv2.imshow("Ryzen AI Classification", frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cap.release()
cv2.destroyAllWindows()
if __name__ == "__main__":
main()
6.3 ユースケース3：バッチ処理での大量画像分類
想定読者: 大量の画像をまとめて分類処理したい方
推奨構成: 任意のRyzen AIプロセッサ + SSD（高速ストレージ）
サンプルコード:
"""
Ryzen AI で大量画像をバッチ分類するサンプル
使い方: python ryzenai_batch_classify.py --input_dir ./images --output results.csv
必要なパッケージ:
pip install onnxruntime numpy pillow pandas tqdm
"""
import os
import argparse
import numpy as np
import pandas as pd
import onnxruntime as ort
from PIL import Image
from pathlib import Path
from tqdm import tqdm
from concurrent.futures import ThreadPoolExecutor
def setup_npu_session(model_path: str) -> ort.InferenceSession:
"""NPUセッションをセットアップ"""
config_path = Path(__file__).parent / "vaip_config_prod.json"
session = ort.InferenceSession(
model_path,
providers=["VitisAIExecutionProvider"],
provider_options=[{
"config_file": str(config_path),
"cacheDir": "./batch_cache",
"cacheKey": "batch_model"
}]
)
return session
def preprocess_image(image_path: str) -> np.ndarray:
"""画像を前処理"""
image = Image.open(image_path).convert("RGB").resize((224, 224))
arr = np.array(image).astype(np.float32) / 255.0
arr = (arr - [0.485, 0.456, 0.406]) / [0.229, 0.224, 0.225]
arr = np.transpose(arr, (2, 0, 1))
return np.expand_dims(arr, axis=0)
def process_batch(session: ort.InferenceSession, image_paths: list) -> list:
"""画像バッチを処理（NPUはbatch=1なので逐次処理）"""
results = []
input_name = session.get_inputs()[0].name
for path in tqdm(image_paths, desc="Processing"):
try:
input_data = preprocess_image(path)
output = session.run(None, {input_name: input_data})[0]
results.append({
"file": os.path.basename(path),
"class_id": int(np.argmax(output)),
"confidence": float(np.max(output)),
"status": "success"
})
except Exception as e:
results.append({
"file": os.path.basename(path),
"class_id": -1,
"confidence": 0.0,
"status": f"error: {str(e)}"
})
return results
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--model", default="resnet50_quantized.onnx")
parser.add_argument("--input_dir", required=True)
parser.add_argument("--output", default="results.csv")
args = parser.parse_args()
# 画像ファイル収集
image_extensions = {".jpg", ".jpeg", ".png", ".bmp"}
image_paths = [
os.path.join(args.input_dir, f)
for f in os.listdir(args.input_dir)
if Path(f).suffix.lower() in image_extensions
]
print(f"[INFO] Found {len(image_paths)} images")
# NPUセッション作成 & バッチ処理
session = setup_npu_session(args.model)
results = process_batch(session, image_paths)
# 結果をCSV出力
df = pd.DataFrame(results)
df.to_csv(args.output, index=False)
print(f"[INFO] Results saved to {args.output}")
print(f"[INFO] Success: {len(df[df['status'] == 'success'])}/{len(df)}")
if __name__ == "__main__":
main()
ユースケースが把握できたところで、この記事を読んだ後の学習パスを確認しましょう。
7. 学習ロードマップ
この記事を読んだ後、次のステップとして以下をおすすめします。
初級者向け（まずはここから）
-
公式Getting Startedを試す
- Ryzen AI Software Documentation
- ResNetチュートリアルで基本的な流れを体験
-
サンプルリポジトリを動かす
- AMD RyzenAI-SW GitHub
- tutorialフォルダの各サンプルを順番に実行
中級者向け（実践に進む）
-
自分のモデルをNPU対応させる
- PyTorch → ONNX変換
- Quark/Vitis AI Quantizerで量子化
- Quark Documentation
-
LLMをローカル実行
- Lemonade SDK
- Llama 3.2、Phi-3などの対応モデルを試す
上級者向け（さらに深く）
-
低レベルAPIを使う
- IRON Toolchain（AMD内部ツール）
- AIE-MLアーキテクチャを直接プログラミング
-
カスタムオペレータの実装
- AMD Versal AIE-ML Architecture Manual (AM020)
- 独自のカーネルを作成してNPU上で実行
8. まとめ
この記事では、AMD XDNAアーキテクチャについて以下を解説しました。
- XDNAとは: Xilinx由来の技術を活用したNPU専用アーキテクチャ
- 空間データフロー: タイルベースの並列処理で省電力・高性能を実現
- 実践的な使い方: ONNX Runtime + VitisAI Execution Providerでの推論実行
- 競合比較: Intel/Qualcommとの差異とAMDの優位性
私の所感
正直に言うと、NPUはまだ「黎明期」にあると感じています。
ソフトウェアエコシステムはGPU（CUDA）に比べると未成熟で、対応モデルも限られています。私自身、最初の環境構築で「なんでこんなに面倒なんだ...」と何度も思いました。
しかし、一度動くようになると、その省電力性能には驚きます。ノートPCのファンが回らずに画像生成やLLM推論ができる体験は、GPUでは得られないものです。
2025年以降、Windows Copilot+ PCの普及とともに、NPUを活用したアプリケーションは急速に増えていくでしょう。今のうちにXDNAの基礎を押さえておくことは、きっと将来の強みになるはずです。
ぜひ、お手元のRyzen AI PCで試してみてください。
参考文献
- AMD XDNA Architecture - AMD公式技術ページ
- Ryzen AI Software Documentation - 公式ドキュメント
- AMD RyzenAI-SW GitHub - サンプルコード集
- AMD XDNA NPU in Ryzen AI Processors (IEEE Micro) - 学術論文
- The Linux Kernel Documentation - AMD NPU - Linuxカーネルドキュメント
- ONNX Runtime Vitis AI Execution Provider - ONNX Runtime公式