✍️ 필사 모드: Edge AI完全ガイド2025: オンデバイス推論、モデル最適化、TensorRT/ONNX/CoreML

import tensorrt as trt
import numpy as np

# TensorRTエンジンビルド
logger = trt.Logger(trt.Logger.WARNING)
builder = trt.Builder(logger)
network = builder.create_network(
    1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
)
parser = trt.OnnxParser(network, logger)

# ONNXモデルのロード
with open("model.onnx", "rb") as f:
    parser.parse(f.read())

# 最適化プロファイル設定
config = builder.create_builder_config()
config.set_memory_pool_limit(trt.MemoryPoolType.WORKSPACE, 1 << 30)  # 1GB

# INT8量子化の有効化
config.set_flag(trt.BuilderFlag.INT8)
config.int8_calibrator = MyCalibrator(calibration_data)

# FP16の有効化
config.set_flag(trt.BuilderFlag.FP16)

# エンジンのビルドとシリアライズ
serialized_engine = builder.build_serialized_network(network, config)
with open("model.engine", "wb") as f:
    f.write(serialized_engine)

1. レイヤーフュージョン: Conv + BatchNorm + ReLUを単一カーネルに統合
2. カーネルオートチューニング: ハードウェアごとに最適なCUDAカーネルを自動選択
3. 動的テンソルメモリ: メモリ再利用で総使用量を削減
4. 精度キャリブレーション: INT8量子化時の精度損失を最小化
5. マルチストリーム実行: 複数の推論を並列実行

import onnxruntime as ort
import numpy as np

# セッションオプションの設定
sess_options = ort.SessionOptions()
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
sess_options.intra_op_num_threads = 4
sess_options.inter_op_num_threads = 2

# Execution Providerの選択
# CPU: CPUExecutionProvider
# GPU: CUDAExecutionProvider, TensorrtExecutionProvider
# モバイル: CoreMLExecutionProvider, NNAPIExecutionProvider
providers = [
    ('TensorrtExecutionProvider', {
        'trt_max_workspace_size': 2147483648,
        'trt_fp16_enable': True,
        'trt_int8_enable': True,
    }),
    ('CUDAExecutionProvider', {
        'device_id': 0,
        'arena_extend_strategy': 'kNextPowerOfTwo',
    }),
    'CPUExecutionProvider'
]

session = ort.InferenceSession("model.onnx", sess_options, providers=providers)

# 推論の実行
input_name = session.get_inputs()[0].name
output = session.run(None, {input_name: input_data})

import tensorflow as tf

# TFLiteモデルへの変換
converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir")

# 量子化設定
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# 完全整数量子化（INT8）
def representative_dataset():
    for data in calibration_data:
        yield [data.astype(np.float32)]

converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8

tflite_model = converter.convert()

# モデルの保存
with open("model_int8.tflite", "wb") as f:
    f.write(tflite_model)

# TFLite推論の実行
interpreter = tf.lite.Interpreter(model_path="model_int8.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()
output = interpreter.get_tensor(output_details[0]['index'])

import coremltools as ct

# PyTorch -> CoreML変換
model = torch.load("model.pt")
model.eval()

traced_model = torch.jit.trace(model, torch.randn(1, 3, 224, 224))
coreml_model = ct.convert(
    traced_model,
    inputs=[ct.ImageType(name="image", shape=(1, 3, 224, 224))],
    compute_precision=ct.precision.FLOAT16,
    compute_units=ct.ComputeUnit.ALL,  # CPU + GPU + Neural Engine
)

# メタデータの追加
coreml_model.author = "ML Team"
coreml_model.short_description = "Image classifier"

coreml_model.save("MyModel.mlpackage")

// SwiftでCoreMLを使用
import CoreML
import Vision

let model = try! MyModel(configuration: MLModelConfiguration())
let request = VNCoreMLRequest(model: try! VNCoreMLModel(for: model.model))

let handler = VNImageRequestHandler(cgImage: image, options: [:])
try! handler.perform([request])

if let results = request.results as? [VNClassificationObservation] {
    print("Top prediction: \(results.first!.identifier)")
}

import openvino as ov

core = ov.Core()

# モデルのロードとコンパイル
model = core.read_model("model.xml")
compiled_model = core.compile_model(model, "CPU", config={
    "PERFORMANCE_HINT": "LATENCY",
    "INFERENCE_NUM_THREADS": "4",
})

# INT8量子化（NNCF）
import nncf

calibration_dataset = nncf.Dataset(calibration_loader)
quantized_model = nncf.quantize(
    model,
    calibration_dataset,
    preset=nncf.QuantizationPreset.MIXED,
    subset_size=300,
)

# 量子化モデルの保存
ov.save_model(quantized_model, "model_int8.xml")

推論ランタイム比較:
========================================
ランタイム    | プラットフォーム | 主要ハードウェア | 言語
TensorRT     | Linux/Windows   | NVIDIA GPU      | C++, Python
ONNX Runtime | クロスプラットフォーム | CPU/GPU/NPU | C++, Python, C#, Java
TFLite       | モバイル/組み込み | CPU/GPU/NPU    | C++, Java, Swift, Python
CoreML       | Apple専用        | ANE/GPU/CPU    | Swift, Objective-C
OpenVINO     | Intel専用        | CPU/iGPU/VPU   | C++, Python
MLC LLM      | クロスプラットフォーム | CPU/GPU/NPU | C++, Python, Swift

# PyTorch PTQの例
import torch
from torch.quantization import quantize_dynamic

# 動的量子化（最もシンプル）
model_fp32 = load_model()
model_int8 = quantize_dynamic(
    model_fp32,
    {torch.nn.Linear, torch.nn.LSTM},
    dtype=torch.qint8
)

# 静的量子化（より高いパフォーマンス）
from torch.quantization import prepare, convert, get_default_qconfig

model_fp32.eval()
model_fp32.qconfig = get_default_qconfig('x86')
model_prepared = prepare(model_fp32)

# キャリブレーションデータで統計を収集
with torch.no_grad():
    for batch in calibration_loader:
        model_prepared(batch)

model_int8 = convert(model_prepared)

import torch
from torch.quantization import prepare_qat, convert

model.train()
model.qconfig = torch.quantization.get_default_qat_qconfig('fbgemm')
model_prepared = prepare_qat(model)

# QAT学習（通常の学習と同じ）
optimizer = torch.optim.Adam(model_prepared.parameters(), lr=1e-4)
for epoch in range(num_epochs):
    for batch in train_loader:
        output = model_prepared(batch)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()

# 量子化モデルへの変換
model_prepared.eval()
model_int8 = convert(model_prepared)

# GPTQ（GPUベースの量子化）
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig

quantize_config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    desc_act=False,
)

model = AutoGPTQForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    quantize_config
)
model.quantize(calibration_data)
model.save_quantized("llama-3.1-8b-gptq-4bit")

# AWQ（Activation-aware Weight Quantization）
from awq import AutoAWQForCausalLM

model = AutoAWQForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")

quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM"
}

model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized("llama-3.1-8b-awq-4bit")

# bitsandbytes（シンプルな量子化）
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    quantization_config=bnb_config,
    device_map="auto",
)

精度     | モデルサイズ(7B基準) | メモリ  | 速度向上 | 精度損失
FP32    | 28GB               | 28GB   | 1x      | 基準
FP16    | 14GB               | 14GB   | 2x      | 無視可能
INT8    | 7GB                | 7GB    | 3-4x    | わずか（0.5%以下）
INT4    | 3.5GB              | 3.5GB  | 4-6x    | 若干（1-2%）

import torch.nn.utils.prune as prune

# 大きさベースのプルーニング（Magnitude-based）
model = load_model()

# モデル全体に50%プルーニングを適用
parameters_to_prune = [
    (module, 'weight') for module in model.modules()
    if isinstance(module, (torch.nn.Linear, torch.nn.Conv2d))
]

prune.global_unstructured(
    parameters_to_prune,
    pruning_method=prune.L1Unstructured,
    amount=0.5,  # 50%プルーニング
)

# プルーニングマスクを永久に適用
for module, name in parameters_to_prune:
    prune.remove(module, name)

# スパース性の確認
total = 0
zero = 0
for p in model.parameters():
    total += p.numel()
    zero += (p == 0).sum().item()
print(f"Sparsity: {zero/total:.2%}")

# Attention Headプルーニングの例
import torch.nn.utils.prune as prune

# 特定レイヤーの出力チャネルを30%プルーニング
prune.ln_structured(
    model.layer1.conv1,
    name='weight',
    amount=0.3,
    n=2,
    dim=0  # 出力チャネル次元
)

プルーニングテクニックの比較:
========================================
テクニック      | スパース性パターン | 実際の速度向上 | 精度
大きさベース    | 非構造化         | 限定的*       | 高い
構造化         | 構造化           | 高い          | 中程度
Movement      | 非構造化         | 限定的*       | 非常に高い

* 非構造化プルーニングは専用ハードウェア/ライブラリが必要

import torch
import torch.nn.functional as F

class DistillationLoss(torch.nn.Module):
    def __init__(self, temperature=4.0, alpha=0.5):
        super().__init__()
        self.temperature = temperature
        self.alpha = alpha
        self.ce_loss = torch.nn.CrossEntropyLoss()

    def forward(self, student_logits, teacher_logits, labels):
        # ソフトターゲット損失（KLダイバージェンス）
        soft_loss = F.kl_div(
            F.log_softmax(student_logits / self.temperature, dim=1),
            F.softmax(teacher_logits / self.temperature, dim=1),
            reduction='batchmean'
        ) * (self.temperature ** 2)

        # ハードターゲット損失（クロスエントロピー）
        hard_loss = self.ce_loss(student_logits, labels)

        return self.alpha * soft_loss + (1 - self.alpha) * hard_loss

# 学習ループ
teacher_model.eval()
student_model.train()

for batch in train_loader:
    inputs, labels = batch
    with torch.no_grad():
        teacher_logits = teacher_model(inputs)
    student_logits = student_model(inputs)

    loss = distillation_loss(student_logits, teacher_logits, labels)
    loss.backward()
    optimizer.step()

教師 -> 生徒モデルの例:
BERT-base (110M) -> DistilBERT (66M): 40%小さく、97%の性能を維持
GPT-4 -> Phi-3 Mini (3.8B): 大型モデルの知識を小型モデルに転移
Llama 70B -> Llama 8B: 知識蒸留 + 合成データで性能を最大化

NASで発見された効率的なアーキテクチャ:
========================================
モデル          | パラメータ | Top-1精度 | 推論速度
EfficientNet-B0| 5.3M      | 77.3%    | 非常に速い
MobileNetV3    | 5.4M      | 75.2%    | 非常に速い
EfficientNetV2 | 21M       | 85.7%    | 速い
MnasNet        | 4.2M      | 74.0%    | 非常に速い

NVIDIAエッジAIハードウェア:
========================================
デバイス         | TOPS | メモリ  | TDP    | 用途
Jetson Orin Nano | 40   | 4-8GB  | 7-15W  | 組み込みAI
Jetson Orin NX   | 100  | 8-16GB | 10-25W | ロボット、ドローン
Jetson AGX Orin  | 275  | 32-64GB| 15-60W | 自動運転、高性能
T4（データセンター）| 130 | 16GB   | 70W    | エッジサーバー
L4（データセンター）| 120 | 24GB   | 72W    | ビデオAI

# JetsonでTensorRT推論を実行
# JetPack SDKインストール後

# モデル変換（ONNX -> TensorRT）
/usr/src/tensorrt/bin/trtexec \
  --onnx=model.onnx \
  --saveEngine=model.engine \
  --fp16 \
  --workspace=2048 \
  --minShapes=input:1x3x224x224 \
  --optShapes=input:4x3x224x224 \
  --maxShapes=input:8x3x224x224

# ベンチマーク
/usr/src/tensorrt/bin/trtexec --loadEngine=model.engine --batch=4

Apple Silicon AIパフォーマンス:
========================================
チップ        | Neural Engine TOPS | GPU     | 統合メモリ
M1           | 11                 | 8コア   | 8-16GB
M2           | 15.8               | 10コア  | 8-24GB
M3           | 18                 | 10コア  | 8-36GB
M4           | 38                 | 10コア  | 16-64GB
A17 Pro      | 35                 | 6コア   | 8GB
A18 Pro      | 35                 | 6コア   | 8GB

# MLXフレームワーク（Apple Siliconネイティブ）
import mlx.core as mx
import mlx.nn as nn

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = nn.Linear(784, 256)
        self.linear2 = nn.Linear(256, 10)

    def __call__(self, x):
        x = nn.relu(self.linear1(x))
        return self.linear2(x)

model = SimpleModel()
input_data = mx.random.normal((1, 784))
output = model(input_data)
mx.eval(output)  # 遅延評価の実行

Qualcomm AIエンジン:
========================================
チップ             | NPU TOPS | 用途
Snapdragon 8 Gen 3 | 45       | フラッグシップスマートフォン
Snapdragon 8 Gen 2 | 36       | プレミアムスマートフォン
Snapdragon 7+ Gen 2| 13       | ミッドレンジスマートフォン
QCS6490            | 12       | IoT、カメラ

# Edge TPUモデルコンパイル
edgetpu_compiler --min_runtime_version 15 model_int8.tflite

# 結果: model_int8_edgetpu.tflite

# MediaPipeリアルタイム推論
import mediapipe as mp
import cv2

mp_hands = mp.solutions.hands
hands = mp_hands.Hands(
    static_image_mode=False,
    max_num_hands=2,
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5,
)

cap = cv2.VideoCapture(0)
while cap.isOpened():
    ret, frame = cap.read()
    results = hands.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            # 21個のランドマークを処理
            pass

Intel AIアクセラレーター:
========================================
ハードウェア        | 性能       | 用途
Core Ultra NPU    | 10-34 TOPS | ノートPC/デスクトップAI
Arc GPU           | 可変       | デスクトップ/ワークステーション
Movidius VPU      | 4 TOPS     | IoT、カメラ（廃止）
Gaudi 2/3         | サーバー級  | エッジサーバー

# ビルド
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make -j$(nproc)

# Metalサポート（macOS）
make LLAMA_METAL=1 -j$(nproc)

# CUDAサポート
make LLAMA_CUDA=1 -j$(nproc)

# モデル量子化（GGUFフォーマット）
./llama-quantize models/llama-3.1-8b-f16.gguf \
  models/llama-3.1-8b-q4_k_m.gguf Q4_K_M

# 推論の実行
./llama-cli \
  -m models/llama-3.1-8b-q4_k_m.gguf \
  -p "Explain quantum computing in simple terms:" \
  -n 256 \
  -ngl 99  # GPUレイヤー数

GGUF量子化比較（Llama 3.1 8B基準）:
========================================
量子化    | サイズ  | メモリ  | 品質     | 速度
Q2_K     | 2.96GB | 5.4GB  | 低い     | 非常に速い
Q3_K_M   | 3.52GB | 6.0GB  | 普通     | 速い
Q4_K_M   | 4.58GB | 7.0GB  | 良い     | 速い
Q5_K_M   | 5.33GB | 7.8GB  | 非常に良い| 普通
Q6_K     | 6.14GB | 8.6GB  | 優秀     | 普通
Q8_0     | 7.95GB | 10.4GB | ほぼ原本  | 遅い
F16      | 15.0GB | 17.5GB | 原本     | 遅い

# MLC LLMのインストール
pip install mlc-llm

# モデルコンパイル（Vulkanバックエンド）
mlc_llm compile ./dist/Llama-3.1-8B-q4f16_1-MLC/ \
  --device vulkan \
  --output ./dist/Llama-3.1-8B-q4f16_1-vulkan/

# iOS/Android向けコンパイル
mlc_llm compile ./dist/Llama-3.1-8B-q4f16_1-MLC/ \
  --device iphone \
  --output ./dist/Llama-3.1-8B-q4f16_1-ios/

# MLXでLLM推論
from mlx_lm import load, generate

model, tokenizer = load("mlx-community/Llama-3.1-8B-Instruct-4bit")

prompt = "What is machine learning?"
response = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=256,
    temp=0.7,
)
print(response)

オンデバイスLLM比較:
========================================
モデル             | サイズ | RAM要件 | 速度(tok/s) | 品質
Phi-3 Mini (3.8B) | 2.3GB | 4GB    | 20-40      | 優秀
Gemma 2 (2B)      | 1.4GB | 3GB    | 30-50      | 良い
Llama 3.2 (1B)    | 0.7GB | 2GB    | 40-60      | 普通
Llama 3.2 (3B)    | 1.8GB | 3.5GB  | 25-40      | 良い
Qwen2.5 (3B)      | 1.8GB | 3.5GB  | 25-40      | 良い
SmolLM (1.7B)     | 1.0GB | 2.5GB  | 35-55      | 普通

* Q4_K_M量子化基準、スマートフォンでの概算値

# FedAvg疑似コード
def federated_averaging(global_model, clients, rounds, local_epochs):
    for round_num in range(rounds):
        # 1. グローバルモデルを各クライアントに配布
        client_models = []
        client_sizes = []

        for client in selected_clients:
            # 2. 各クライアントでローカル学習
            local_model = copy.deepcopy(global_model)
            local_model = train_local(
                local_model,
                client.data,
                epochs=local_epochs,
                lr=0.01
            )
            client_models.append(local_model.state_dict())
            client_sizes.append(len(client.data))

        # 3. 加重平均でグローバルモデルを更新
        total_size = sum(client_sizes)
        new_global = {}
        for key in global_model.state_dict():
            new_global[key] = sum(
                client_models[i][key] * (client_sizes[i] / total_size)
                for i in range(len(client_models))
            )
        global_model.load_state_dict(new_global)

    return global_model

# Flowerサーバー
import flwr as fl

strategy = fl.server.strategy.FedAvg(
    fraction_fit=0.3,          # 30%のクライアントが参加
    fraction_evaluate=0.2,     # 20%のクライアントが評価
    min_fit_clients=2,         # 最小参加クライアント数
    min_evaluate_clients=2,
    min_available_clients=3,
)

fl.server.start_server(
    server_address="0.0.0.0:8080",
    config=fl.server.ServerConfig(num_rounds=10),
    strategy=strategy,
)

# Flowerクライアント
import flwr as fl
import torch

class FlowerClient(fl.client.NumPyClient):
    def __init__(self, model, trainloader, testloader):
        self.model = model
        self.trainloader = trainloader
        self.testloader = testloader

    def get_parameters(self, config):
        return [val.cpu().numpy() for val in self.model.parameters()]

    def set_parameters(self, parameters):
        for param, new_val in zip(self.model.parameters(), parameters):
            param.data = torch.tensor(new_val)

    def fit(self, parameters, config):
        self.set_parameters(parameters)
        train(self.model, self.trainloader, epochs=1)
        return self.get_parameters(config), len(self.trainloader.dataset), {}

    def evaluate(self, parameters, config):
        self.set_parameters(parameters)
        loss, accuracy = test(self.model, self.testloader)
        return float(loss), len(self.testloader.dataset), {"accuracy": float(accuracy)}

fl.client.start_numpy_client(
    server_address="localhost:8080",
    client=FlowerClient(model, trainloader, testloader),
)

# Opacusを使った差分プライバシー学習
from opacus import PrivacyEngine

model = create_model()
optimizer = torch.optim.SGD(model.parameters(), lr=0.05)

privacy_engine = PrivacyEngine()
model, optimizer, train_loader = privacy_engine.make_private_with_epsilon(
    module=model,
    optimizer=optimizer,
    data_loader=train_loader,
    epochs=10,
    target_epsilon=1.0,    # プライバシー予算
    target_delta=1e-5,     # 失敗確率
    max_grad_norm=1.0,     # 勾配クリッピング
)

# 学習（通常の学習と同じ）
for batch in train_loader:
    output = model(batch)
    loss = criterion(output, target)
    loss.backward()
    optimizer.step()

# 使用されたプライバシー予算を確認
epsilon = privacy_engine.get_epsilon(delta=1e-5)
print(f"Epsilon: {epsilon:.2f}")

オンデバイスプライバシー保護の事例:
========================================
事例                     | 技術                     | プライバシー保証
Apple Face ID            | Neural Engine + Secure Enclave | 顔データをデバイス内で処理
Googleキーボード予測      | 連合学習                 | タイピングデータをサーバーに送信しない
Apple Siri音声認識       | CoreMLオンデバイス        | 音声データをローカルで処理
Samsung Knox AI          | NPU + TEE               | 企業データの隔離

Secure Aggregationプロトコル:
========================================
1. 各クライアントがマスクを生成（ペアワイズシード交換）
2. ローカルモデル更新にマスクを加えて送信
3. サーバーはマスクされた更新のみ収集
4. 集約時にマスクが相殺されて合計のみ復元
5. 個別の更新はサーバーも復元不可能

学習フレームワーク -> 中間形式 -> 推論エンジン -> デバイス
========================================
PyTorch  --+
            +---> ONNX --+---> TensorRT (.engine)  ---> NVIDIA GPU
TensorFlow-+             +---> ONNX Runtime         ---> クロスプラットフォーム
            |             +---> OpenVINO (.xml)      ---> Intel
            +---> TFLite ---> TFLite Runtime         ---> モバイル/IoT
            +---> CoreML ---> CoreML Runtime          ---> Apple
            +---> GGUF   ---> llama.cpp              ---> 全プラットフォーム

# モデルバージョン管理とOTAアップデートの例
import hashlib
import json
import requests

class ModelManager:
    def __init__(self, model_dir, manifest_url):
        self.model_dir = model_dir
        self.manifest_url = manifest_url

    def check_update(self):
        """サーバーから最新モデルマニフェストを確認"""
        manifest = requests.get(self.manifest_url).json()
        current_version = self.get_current_version()

        if manifest["version"] > current_version:
            return manifest
        return None

    def download_model(self, manifest):
        """デルタアップデートまたは全体ダウンロード"""
        if manifest.get("delta_url"):
            # デルタパッチのダウンロード（サイズ削減）
            patch = requests.get(manifest["delta_url"]).content
            self.apply_delta(patch)
        else:
            # モデル全体のダウンロード
            model_data = requests.get(manifest["model_url"]).content
            self.save_model(model_data, manifest)

    def validate_model(self, model_path, expected_hash):
        """SHA-256ハッシュで整合性を検証"""
        with open(model_path, "rb") as f:
            file_hash = hashlib.sha256(f.read()).hexdigest()
        return file_hash == expected_hash

    def rollback(self):
        """問題発生時に前のバージョンにロールバック"""
        # 前のバージョンの復元ロジック
        pass

# モデルマニフェスト（model_manifest.json）
model_name: "image-classifier-v2"
version: "2.1.0"
framework: "tflite"
file: "model_int8.tflite"
input_shape: [1, 224, 224, 3]
input_type: "uint8"
output_shape: [1, 1000]
labels_file: "labels.txt"
hardware_requirements:
  min_ram_mb: 256
  supported_delegates: ["gpu", "nnapi", "xnnpack"]
metrics:
  accuracy: 0.943
  latency_ms: 12.5
  model_size_mb: 4.2

自動運転Edge AIスタック:
========================================
センサー        | AIタスク            | ハードウェア     | レイテンシ要件
カメラ（8-12台）| 物体検出/分類       | NVIDIA Orin     | 10ms以下
LiDAR          | 3Dポイントクラウド   | NVIDIA Orin     | 20ms以下
レーダー        | 距離/速度推定       | DSP            | 5ms以下
フュージョン    | センサー融合/判断    | NVIDIA Orin     | 30ms以下
計画           | 経路計画            | CPU/GPU        | 50ms以下

# エッジデバイスでのリアルタイム物体検出
import cv2
import numpy as np

# TFLiteモデルのロード（SSD MobileNet）
interpreter = tf.lite.Interpreter(
    model_path="ssd_mobilenet_v2_int8.tflite",
    num_threads=4
)
interpreter.allocate_tensors()

cap = cv2.VideoCapture(0)
while True:
    ret, frame = cap.read()
    # 前処理
    input_data = preprocess(frame, target_size=(300, 300))

    # 推論
    interpreter.set_tensor(input_details[0]['index'], input_data)
    interpreter.invoke()

    # 結果のパース
    boxes = interpreter.get_tensor(output_details[0]['index'])
    classes = interpreter.get_tensor(output_details[1]['index'])
    scores = interpreter.get_tensor(output_details[2]['index'])

    # 高い信頼度の結果のみ表示
    for i in range(len(scores[0])):
        if scores[0][i] > 0.5:
            draw_box(frame, boxes[0][i], classes[0][i], scores[0][i])

オンデバイス音声処理パイプライン:
========================================
1. ウェイクワード検出: 小さなモデル（50KB-1MB）、常時実行、NPU
2. 音声アクティビティ検出（VAD）: 音声区間の識別、非常に軽量
3. 音声認識（ASR）: Whisper Tiny/Base（39M-74Mパラメータ）
4. 自然言語理解（NLU）: 意図分類 + 固有表現認識
5. 応答生成: 小型LLMまたはテンプレートベース
6. 音声合成（TTS）: テキストを音声に変換

医療Edge AIの活用:
========================================
機器            | AIタスク              | 規制上の考慮事項
スマートウォッチ | ECG不整脈検出        | FDAクラスII
聴診器          | 心音/肺音分析         | FDAクラスII
眼底カメラ      | 糖尿病網膜症スクリーニング | FDAクラスII
CT/MRI補助     | 病変ハイライト検出     | FDAクラスIII
血糖モニター    | 血糖トレンド予測      | FDAクラスII

産業Edge AIの活用:
========================================
領域            | AIタスク              | メリット
品質検査        | 視覚的欠陥検出        | リアルタイム、100%検査
予知保全        | 振動/騒音異常検出     | ダウンタイム40%削減
エネルギー最適化| 消費パターン予測      | エネルギー15%節約
安全監視        | PPE装着確認           | 事故予防
ロボット制御    | 経路計画/障害物回避   | 自律運転

電力効率の比較:
========================================
デバイス               | 電力  | AI性能   | TOPS/W
NVIDIA Jetson Orin Nano| 7-15W | 40 TOPS | 2.7-5.7
Apple A18 Pro          | ~5W   | 35 TOPS | 7.0
Google Edge TPU        | 2W    | 4 TOPS  | 2.0
Qualcomm Snapdragon 8g3| ~5W  | 45 TOPS | 9.0
Intel Core Ultra NPU   | ~5W  | 34 TOPS | 6.8

デバイスタイプ別メモリ制約:
========================================
デバイスタイプ     | 一般的なRAM | AI利用可能メモリ
IoTセンサー       | 256KB-4MB  | 極めて限定的
マイクロコントローラ| 2-16MB    | 非常に限定的
スマートカメラ    | 256MB-2GB  | 数百MB
スマートフォン    | 6-16GB     | 2-8GB
エッジサーバー    | 16-128GB   | ほとんど利用可能

OTAモデル更新の課題:
========================================
- 帯域幅の制限: 大容量モデルをワイヤレスで転送
- バッテリー消費: ダウンロード + 変換プロセスのエネルギー
- A/Bテスト: 旧版/新版の同時保管が必要
- ロールバック: 失敗時の前バージョン復旧メカニズム
- 整合性: モデル改ざん防止（署名/ハッシュ検証）