# JetPack SDK のインストール（推奨）
# JetPack 6.x はJetson Orin シリーズ向け
 
# 1. NVIDIA SDK Managerをホストマシンにインストール
# https://developer.nvidia.com/sdk-manager
 
# 2. Jetsonデバイスをリカバリモードで接続
# ボタン操作でリカバリモードに入る
 
# 3. SDK Manager でフラッシュ
# JetPack 6.0 = Ubuntu 22.04 + CUDA 12.2 + cuDNN + TensorRT
 
# 4. 初期設定後の確認
jetson_release  # JetPack バージョン確認
nvidia-smi      # GPU状態確認（注: jtopの方が詳細）
 
# jtop のインストール（Jetson用モニタリングツール）
sudo pip3 install jetson-stats
sudo systemctl restart jtop.service
jtop  # GPU/CPU/メモリ/温度をリアルタイム表示
 
# Docker + NVIDIA Container Runtime の確認
sudo docker run --runtime nvidia --rm nvcr.io/nvidia/l4t-base:r36.2.0 \
    nvidia-smi

# Jetson で TensorRT を使った高速推論
import tensorrt as trt
import pycuda.driver as cuda
import pycuda.autoinit
import numpy as np
 
def load_engine(engine_path):
    """TensorRT エンジンのロード"""
    logger = trt.Logger(trt.Logger.WARNING)
    with open(engine_path, "rb") as f, \
         trt.Runtime(logger) as runtime:
        return runtime.deserialize_cuda_engine(f.read())
 
def infer(engine, input_data):
    """推論実行"""
    context = engine.create_execution_context()
 
    # 入出力バッファの確保
    h_input = np.ascontiguousarray(input_data)
    h_output = np.empty(output_shape, dtype=np.float32)
 
    d_input = cuda.mem_alloc(h_input.nbytes)
    d_output = cuda.mem_alloc(h_output.nbytes)
 
    # ホスト→デバイス転送
    cuda.memcpy_htod(d_input, h_input)
 
    # 推論実行
    context.execute_v2([int(d_input), int(d_output)])
 
    # デバイス→ホスト転送
    cuda.memcpy_dtoh(h_output, d_output)
 
    return h_output
 
# ONNX → TensorRT 変換コマンド
# trtexec --onnx=model.onnx --saveEngine=model.trt --fp16

import jetson_inference
import jetson_utils
 
# モデルロード（自動的に TensorRT に最適化される）
net = jetson_inference.detectNet("ssd-mobilenet-v2", threshold=0.5)
 
# カメラ入力
camera = jetson_utils.videoSource("csi://0")  # CSI カメラ
display = jetson_utils.videoOutput("display://0")
 
while display.IsStreaming():
    img = camera.Capture()
 
    # 物体検出（GPU で推論）
    detections = net.Detect(img)
 
    for det in detections:
        print(f"検出: {net.GetClassDesc(det.ClassID)} "
              f"信頼度: {det.Confidence:.2f} "
              f"位置: ({det.Left:.0f},{det.Top:.0f})-({det.Right:.0f},{det.Bottom:.0f})")
 
    display.Render(img)
    display.SetStatus(f"FPS: {net.GetNetworkFPS():.0f}")

from ultralytics import YOLO
import cv2
 
# YOLOv8 モデルをロード
model = YOLO("yolov8n.pt")
 
# TensorRT にエクスポート（Jetson上で実行）
model.export(format="engine", half=True, device=0)
 
# TensorRT エンジンで推論
model_trt = YOLO("yolov8n.engine")
 
# カメラからリアルタイム推論
cap = cv2.VideoCapture(0)
 
while True:
    ret, frame = cap.read()
    if not ret:
        break
 
    # 推論実行
    results = model_trt(frame, stream=True, verbose=False)
 
    for result in results:
        annotated = result.plot()
        cv2.imshow("YOLOv8 on Jetson", annotated)
 
        # 検出結果の詳細
        for box in result.boxes:
            cls = int(box.cls[0])
            conf = float(box.conf[0])
            label = result.names[cls]
            print(f"{label}: {conf:.2f}")
 
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break
 
cap.release()
cv2.destroyAllWindows()

import threading
from queue import Queue
import cv2
import numpy as np
 
class MultiStreamInference:
    """複数カメラからの同時推論パイプライン"""
 
    def __init__(self, model_path, num_streams=4):
        self.model = load_tensorrt_engine(model_path)
        self.num_streams = num_streams
        self.result_queues = [Queue(maxsize=10) for _ in range(num_streams)]
        self.running = True
 
    def capture_and_infer(self, stream_id, source):
        """各ストリームのキャプチャ→推論ループ"""
        cap = cv2.VideoCapture(source)
        cuda_stream = cuda.Stream()  # 非同期CUDA Stream
 
        while self.running:
            ret, frame = cap.read()
            if not ret:
                continue
 
            # 前処理（リサイズ、正規化）
            input_tensor = preprocess(frame, target_size=(640, 640))
 
            # 非同期推論（CUDAストリームで並列実行）
            output = self.model.infer_async(
                input_tensor,
                stream=cuda_stream
            )
            cuda_stream.synchronize()
 
            # 後処理（NMS、バウンディングボックス描画）
            detections = postprocess(output, conf_threshold=0.5)
 
            self.result_queues[stream_id].put({
                'stream_id': stream_id,
                'frame': frame,
                'detections': detections,
            })
 
        cap.release()
 
    def start(self, sources):
        """全ストリームを起動"""
        threads = []
        for i, source in enumerate(sources):
            t = threading.Thread(
                target=self.capture_and_infer,
                args=(i, source)
            )
            t.daemon = True
            t.start()
            threads.append(t)
        return threads
 
# 使用例: 4台のカメラから同時推論
pipeline = MultiStreamInference("yolov8n.engine", num_streams=4)
sources = [
    "rtsp://192.168.1.101/stream",
    "rtsp://192.168.1.102/stream",
    "rtsp://192.168.1.103/stream",
    "rtsp://192.168.1.104/stream",
]
pipeline.start(sources)

# Google Coral Edge TPU を使った画像分類
from pycoral.adapters import classify
from pycoral.adapters import common
from pycoral.utils.dataset import read_label_file
from pycoral.utils.edgetpu import make_interpreter
from PIL import Image
 
# Edge TPU 用にコンパイル済みモデルをロード
interpreter = make_interpreter("mobilenet_v2_1.0_224_quant_edgetpu.tflite")
interpreter.allocate_tensors()
 
# ラベル読み込み
labels = read_label_file("imagenet_labels.txt")
 
# 画像の前処理と推論
image = Image.open("cat.jpg").resize(
    common.input_size(interpreter), Image.LANCZOS
)
common.set_input(interpreter, image)
 
# 推論実行（Edge TPU で高速処理）
interpreter.invoke()
 
# 結果取得
classes = classify.get_classes(interpreter, top_k=5)
for c in classes:
    print(f"{labels.get(c.id, c.id)}: {c.score:.4f}")
 
# 推論時間の計測
import time
start = time.perf_counter()
for _ in range(100):
    interpreter.invoke()
elapsed = (time.perf_counter() - start) / 100
print(f"推論時間: {elapsed*1000:.1f} ms ({1/elapsed:.0f} FPS)")

# Coral USB Accelerator の場合
 
# 1. Edge TPU ランタイムのインストール
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | \
    sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | \
    sudo apt-key add -
sudo apt-get update
sudo apt-get install libedgetpu1-std  # 標準クロック
# sudo apt-get install libedgetpu1-max  # 最大クロック（発熱注意）
 
# 2. PyCoral のインストール
pip3 install pycoral
 
# 3. モデルのダウンロード
wget https://github.com/google-coral/test_data/raw/master/\
mobilenet_v2_1.0_224_quant_edgetpu.tflite
 
# 4. Edge TPU Compiler のインストール
curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | \
    sudo apt-key add -
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | \
    sudo tee /etc/apt/sources.list.d/coral-edgetpu.list
sudo apt-get update
sudo apt-get install edgetpu-compiler
 
# 5. カスタムモデルのコンパイル
edgetpu_compiler my_model_quant.tflite
# → my_model_quant_edgetpu.tflite が生成される

from pycoral.adapters import detect
from pycoral.adapters import common
from pycoral.utils.dataset import read_label_file
from pycoral.utils.edgetpu import make_interpreter
from PIL import Image, ImageDraw
import time
 
class CoralObjectDetector:
    """Coral Edge TPU を使った物体検出"""
 
    def __init__(self, model_path, labels_path, threshold=0.5):
        self.interpreter = make_interpreter(model_path)
        self.interpreter.allocate_tensors()
        self.labels = read_label_file(labels_path)
        self.threshold = threshold
        self.input_size = common.input_size(self.interpreter)
 
    def detect(self, image):
        """画像から物体を検出"""
        # リサイズ
        resized = image.resize(self.input_size, Image.LANCZOS)
        common.set_input(self.interpreter, resized)
 
        # 推論
        start = time.perf_counter()
        self.interpreter.invoke()
        inference_time = time.perf_counter() - start
 
        # 結果取得
        objs = detect.get_objects(
            self.interpreter,
            score_threshold=self.threshold
        )
 
        results = []
        for obj in objs:
            bbox = obj.bbox
            # 元画像サイズにスケール
            scale_x = image.width / self.input_size[0]
            scale_y = image.height / self.input_size[1]
 
            results.append({
                'label': self.labels.get(obj.id, str(obj.id)),
                'score': float(obj.score),
                'bbox': (
                    int(bbox.xmin * scale_x),
                    int(bbox.ymin * scale_y),
                    int(bbox.xmax * scale_x),
                    int(bbox.ymax * scale_y),
                ),
            })
 
        return results, inference_time
 
    def draw_results(self, image, results):
        """検出結果を画像に描画"""
        draw = ImageDraw.Draw(image)
        for r in results:
            bbox = r['bbox']
            draw.rectangle(bbox, outline='red', width=2)
            draw.text(
                (bbox[0], bbox[1] - 15),
                f"{r['label']}: {r['score']:.2f}",
                fill='red'
            )
        return image
 
# 使用例
detector = CoralObjectDetector(
    "ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite",
    "coco_labels.txt",
    threshold=0.5
)
 
image = Image.open("street.jpg")
results, time_ms = detector.detect(image)
print(f"推論時間: {time_ms*1000:.1f}ms, 検出数: {len(results)}")
for r in results:
    print(f"  {r['label']}: {r['score']:.2f} @ {r['bbox']}")

# Python (coremltools) でモデル変換
import coremltools as ct
import torch
 
# PyTorch モデルを Core ML に変換
model = torchvision.models.mobilenet_v2(pretrained=True)
model.eval()
 
example_input = torch.rand(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)
 
mlmodel = ct.convert(
    traced_model,
    inputs=[ct.ImageType(shape=(1, 3, 224, 224), scale=1/255.0)],
    compute_units=ct.ComputeUnit.ALL,  # CPU + GPU + Neural Engine
)
mlmodel.save("MobileNetV2.mlpackage")

// Swift での推論（Neural Engine 自動活用）
import CoreML
import Vision
 
let model = try! MobileNetV2(configuration: .init())
 
let request = VNCoreMLRequest(model: try! VNCoreMLModel(for: model.model)) {
    request, error in
    guard let results = request.results as? [VNClassificationObservation] else { return }
    let top = results.prefix(3)
    for result in top {
        print("\(result.identifier): \(result.confidence * 100)%")
    }
}
 
// Neural Engine で推論: ~1ms / 画像

import CoreML
 
class OnDeviceLLM {
    let model: MLModel
    let tokenizer: BPETokenizer
 
    init(modelPath: String, tokenizerPath: String) throws {
        let config = MLModelConfiguration()
        config.computeUnits = .all  // CPU + GPU + Neural Engine
 
        self.model = try MLModel(contentsOf: URL(fileURLWithPath: modelPath),
                                  configuration: config)
        self.tokenizer = try BPETokenizer(mergesFile: tokenizerPath)
    }
 
    func generate(prompt: String, maxTokens: Int = 100) throws -> String {
        var tokens = tokenizer.encode(prompt)
        var generatedText = ""
 
        for _ in 0..<maxTokens {
            // 入力準備
            let inputArray = try MLMultiArray(shape: [1, NSNumber(value: tokens.count)],
                                             dataType: .int32)
            for (i, token) in tokens.enumerated() {
                inputArray[i] = NSNumber(value: token)
            }
 
            // 推論（Neural Engineで高速実行）
            let input = try MLDictionaryFeatureProvider(
                dictionary: ["input_ids": MLFeatureValue(multiArray: inputArray)]
            )
            let output = try model.prediction(from: input)
 
            // 次のトークンを取得
            guard let logits = output.featureValue(for: "logits")?.multiArrayValue else {
                break
            }
            let nextToken = argmax(logits)
 
            if nextToken == tokenizer.eosToken {
                break
            }
 
            tokens.append(nextToken)
            generatedText += tokenizer.decode([nextToken])
        }
 
        return generatedText
    }
 
    private func argmax(_ array: MLMultiArray) -> Int {
        var maxVal: Float = -Float.infinity
        var maxIdx = 0
        let lastDim = array.shape.last!.intValue
        let offset = (array.count - lastDim)
 
        for i in 0..<lastDim {
            let val = array[offset + i].floatValue
            if val > maxVal {
                maxVal = val
                maxIdx = i
            }
        }
        return maxIdx
    }
}

# Qualcomm AI Engine Direct (QNN) での推論
# スマートフォン上の Hexagon NPU を活用
 
# モデル変換: ONNX → QNN
# qnn-onnx-converter --input_network model.onnx \
#     --output_path model.cpp \
#     --input_dim "input" 1,3,224,224
 
# 量子化（Hexagon NPU 向け）
# qnn-net-run --model model.so \
#     --backend libQnnHtp.so \
#     --input_list input_list.txt
 
# Android アプリでの使用 (Java/Kotlin)
# Qualcomm Neural Processing SDK を使用

# ONNX Runtime で NPU を活用（Windows AI PC）
import onnxruntime as ort
import numpy as np
 
class WindowsNPUInference:
    """Windows AI PC の NPU を使った推論"""
 
    def __init__(self, model_path):
        # NPU (DML) を使用するセッション設定
        providers = [
            ('DmlExecutionProvider', {
                'device_id': 0,
                'enable_dynamic_graph_fusion': True,
            }),
            'CPUExecutionProvider',  # フォールバック
        ]
 
        self.session = ort.InferenceSession(
            model_path,
            providers=providers
        )
 
        # 入出力情報の取得
        self.input_name = self.session.get_inputs()[0].name
        self.output_name = self.session.get_outputs()[0].name
 
    def predict(self, input_data):
        """NPU上で推論実行"""
        result = self.session.run(
            [self.output_name],
            {self.input_name: input_data}
        )
        return result[0]
 
    @staticmethod
    def check_npu_availability():
        """NPU の利用可能性を確認"""
        providers = ort.get_available_providers()
        print(f"利用可能なプロバイダ: {providers}")
        if 'DmlExecutionProvider' in providers:
            print("DirectML (NPU/GPU) が利用可能")
            return True
        else:
            print("DirectML が利用不可 — CPUフォールバック")
            return False
 
# 使用例
WindowsNPUInference.check_npu_availability()
inferencer = WindowsNPUInference("model.onnx")
result = inferencer.predict(input_array)

import torch
from torch.quantization import quantize_dynamic, quantize_static
 
# 動的量子化（推論時に量子化）
# 最も簡単な方法、精度劣化が少ない
model_fp32 = load_model("resnet50.pth")
model_int8 = quantize_dynamic(
    model_fp32,
    {torch.nn.Linear, torch.nn.Conv2d},  # 量子化対象レイヤー
    dtype=torch.qint8
)
 
# モデルサイズの比較
import os
torch.save(model_fp32.state_dict(), "model_fp32.pth")
torch.save(model_int8.state_dict(), "model_int8.pth")
size_fp32 = os.path.getsize("model_fp32.pth") / 1e6
size_int8 = os.path.getsize("model_int8.pth") / 1e6
print(f"FP32: {size_fp32:.1f}MB → INT8: {size_int8:.1f}MB ({size_int8/size_fp32*100:.0f}%)")

import torch
import torch.nn as nn
import torch.nn.functional as F
 
class DistillationLoss(nn.Module):
    """知識蒸留の損失関数"""
 
    def __init__(self, temperature=4.0, alpha=0.5):
        super().__init__()
        self.temperature = temperature
        self.alpha = alpha
 
    def forward(self, student_logits, teacher_logits, labels):
        # ソフトターゲット損失（教師の知識を蒸留）
        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 = F.cross_entropy(student_logits, labels)
 
        return self.alpha * soft_loss + (1 - self.alpha) * hard_loss
 
def train_with_distillation(teacher, student, train_loader, epochs=50):
    """教師モデルの知識を生徒モデルに蒸留"""
    teacher.eval()  # 教師は推論モードで固定
    student.train()
 
    optimizer = torch.optim.Adam(student.parameters(), lr=1e-3)
    criterion = DistillationLoss(temperature=4.0, alpha=0.5)
 
    for epoch in range(epochs):
        total_loss = 0
        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)
 
            # 教師の推論（勾配計算不要）
            with torch.no_grad():
                teacher_logits = teacher(images)
 
            # 生徒の推論
            student_logits = student(images)
 
            # 蒸留損失
            loss = criterion(student_logits, teacher_logits, labels)
 
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
 
        print(f"Epoch {epoch}: Loss = {total_loss / len(train_loader):.4f}")
 
# 使用例
# 教師: ResNet-50 (25.6M params, 97.8MB)
# 生徒: MobileNet-V3 (5.4M params, 21.8MB)
teacher = torchvision.models.resnet50(pretrained=True)
student = torchvision.models.mobilenet_v3_small(pretrained=False)
train_with_distillation(teacher, student, train_loader)

import torch
import torch.nn.utils.prune as prune
 
def structured_pruning(model, amount=0.3):
    """構造化プルーニング（チャネル単位で削除）"""
 
    for name, module in model.named_modules():
        if isinstance(module, torch.nn.Conv2d):
            # L1ノルムベースでチャネルをプルーニング
            prune.ln_structured(
                module,
                name='weight',
                amount=amount,
                n=1,  # L1ノルム
                dim=0  # 出力チャネル次元
            )
            # プルーニングを永続化
            prune.remove(module, 'weight')
 
    return model
 
def evaluate_pruned_model(model, test_loader):
    """プルーニング後のモデル評価"""
    model.eval()
    total_params = sum(p.numel() for p in model.parameters())
    zero_params = sum((p == 0).sum().item() for p in model.parameters())
    sparsity = zero_params / total_params
 
    correct = 0
    total = 0
    with torch.no_grad():
        for images, labels in test_loader:
            outputs = model(images.to(device))
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels.to(device)).sum().item()
 
    accuracy = correct / total
    print(f"スパース率: {sparsity*100:.1f}%")
    print(f"精度: {accuracy*100:.1f}%")
    print(f"パラメータ数: {total_params:,} (ゼロ: {zero_params:,})")
 
    return accuracy, sparsity

import torch
import onnx
import onnxruntime as ort
 
def export_to_onnx(model, input_shape, output_path):
    """PyTorch モデルを ONNX 形式にエクスポート"""
    model.eval()
    dummy_input = torch.randn(*input_shape)
 
    torch.onnx.export(
        model,
        dummy_input,
        output_path,
        export_params=True,
        opset_version=17,
        do_constant_folding=True,
        input_names=['input'],
        output_names=['output'],
        dynamic_axes={
            'input': {0: 'batch_size'},
            'output': {0: 'batch_size'},
        }
    )
 
    # モデルの検証
    onnx_model = onnx.load(output_path)
    onnx.checker.check_model(onnx_model)
    print(f"ONNX エクスポート完了: {output_path}")
 
def optimize_onnx(input_path, output_path):
    """ONNX モデルの最適化"""
    import onnxoptimizer
 
    model = onnx.load(input_path)
    optimized = onnxoptimizer.optimize(model, [
        'eliminate_deadend',
        'eliminate_identity',
        'eliminate_nop_dropout',
        'fuse_bn_into_conv',
        'fuse_consecutive_transposes',
    ])
    onnx.save(optimized, output_path)
    print(f"最適化完了: {output_path}")
 
def benchmark_onnx(model_path, input_shape, num_runs=100):
    """ONNX Runtime での推論速度ベンチマーク"""
    session = ort.InferenceSession(model_path)
    input_name = session.get_inputs()[0].name
 
    dummy = np.random.randn(*input_shape).astype(np.float32)
 
    # ウォームアップ
    for _ in range(10):
        session.run(None, {input_name: dummy})
 
    # ベンチマーク
    import time
    start = time.perf_counter()
    for _ in range(num_runs):
        session.run(None, {input_name: dummy})
    elapsed = (time.perf_counter() - start) / num_runs
 
    print(f"推論時間: {elapsed*1000:.2f}ms ({1/elapsed:.0f} FPS)")

import numpy as np
from sklearn.ensemble import IsolationForest
import onnxruntime as ort
 
class EdgeAnomalyDetector:
    """エッジデバイスでの製造ライン異常検知"""
 
    def __init__(self, model_path, threshold=-0.5):
        self.session = ort.InferenceSession(model_path)
        self.threshold = threshold
        self.feature_buffer = []
        self.alert_callback = None
 
    def extract_features(self, image):
        """画像から特徴量を抽出"""
        input_name = self.session.get_inputs()[0].name
        preprocessed = self.preprocess(image)
        features = self.session.run(None, {input_name: preprocessed})[0]
        return features.flatten()
 
    def detect(self, image):
        """異常検知"""
        features = self.extract_features(image)
 
        # 統計的異常検知（エッジで軽量に動作）
        self.feature_buffer.append(features)
        if len(self.feature_buffer) < 100:
            return {'status': 'collecting', 'samples': len(self.feature_buffer)}
 
        # Isolation Forestで異常スコア計算
        if len(self.feature_buffer) == 100:
            self.model = IsolationForest(contamination=0.05)
            self.model.fit(np.array(self.feature_buffer))
 
        score = self.model.decision_function([features])[0]
        is_anomaly = score < self.threshold
 
        if is_anomaly and self.alert_callback:
            self.alert_callback(image, score)
 
        return {
            'status': 'anomaly' if is_anomaly else 'normal',
            'score': float(score),
            'threshold': self.threshold,
        }
 
    def preprocess(self, image):
        """画像前処理"""
        resized = cv2.resize(image, (224, 224))
        normalized = resized.astype(np.float32) / 255.0
        return np.expand_dims(normalized.transpose(2, 0, 1), 0)

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md