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  # 출력 채널 차원
)

프루닝 기법 비교:
========================================
기법          | 희소성 패턴 | 실제 속도 향상 | 정확도 보존
크기 기반     | 비구조적   | 제한적*       | 높음
구조적        | 구조적     | 높음          | 중간
이동 프루닝   | 비구조적   | 제한적*       | 매우 높음

* 비구조적 프루닝은 전용 하드웨어/라이브러리 필요

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 Divergence)
        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)

        # 하드 타겟 손실 (Cross-Entropy)
        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 Engine:
========================================
칩셋              | 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| 노트북/데스크탑 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 Keyboard 예측     | Federated Learning      | 타이핑 데이터 서버 미전송
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. Wake Word 탐지: 작은 모델 (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 테스트: 구버전/신버전 동시 보관 필요
- 롤백: 실패 시 이전 버전 복구 메커니즘
- 무결성: 모델 변조 방지 (서명/해시 검증)