モデル圧縮とは

モデル圧縮（Model Compression）は、大規模な機械学習モデルのサイズ、計算量、メモリ使用量を削減しながら、予測性能を可能な限り維持する技術分野です。量子化、プルーニング、知識蒸留、低ランク近似などの手法を通じて、元のモデルの知識を効率的な形で表現し直します。エッジデバイス、モバイル環境、リアルタイム推論など、計算資源が制限された環境でのAI活用を可能にする重要な技術であり、AI の民主化と実用化の鍵となる分野です。

背景と重要性

現代の高性能AIモデル、特に大規模言語モデルや深層ニューラルネットワークは、優れた性能を示す一方で、膨大なパラメータ数と計算量を必要とします。これにより、高価なGPUやクラウドインフラが必要となり、実用的な展開が困難になる場合があります。

モデル圧縮は、

• エッジデバイスでのAI実行
• 推論速度の向上
• エネルギー消費の削減
• 展開コストの低減

を実現することで、AI技術をより身近で持続可能なものにします。適切な圧縮により、高い性能を維持しながら実用的なサイズのモデルを構築できます。

主な構成要素

量子化（Quantization）

浮動小数点数の精度を下げて計算効率を向上させる手法です。

プルーニング（Pruning）

重要でないパラメータを除去してモデルを軽量化する手法です。

知識蒸留（Knowledge Distillation）

大規模モデルの知識を小規模モデルに転移する手法です。

低ランク近似（Low-rank Approximation）

行列分解により計算量を削減する手法です。

アーキテクチャ最適化（Architecture Optimization）

効率的なモデル構造の設計・探索です。

動的推論（Dynamic Inference）

入力に応じて計算量を適応的に調整する手法です。

主な特徴

多面性

複数の圧縮手法を組み合わせて使用できます。

トレードオフ性

圧縮率と性能維持のバランスが重要です。

タスク依存性

アプリケーションに応じた最適化が必要です。

圧縮手法の詳細

量子化（Quantization）

重み量子化：

import numpy as np
import torch
import torch.nn as nn
import torch.quantization as quant

class QuantizationCompressor:
    def __init__(self, model):
        self.original_model = model
        self.quantized_model = None
        self.compression_stats = {}
    
    def apply_post_training_quantization(self, calibration_data=None, quantization_type='dynamic'):
        """訓練後量子化の適用"""
        
        if quantization_type == 'dynamic':
            # 動的量子化（実行時に量子化）
            self.quantized_model = torch.quantization.quantize_dynamic(
                self.original_model,
                {torch.nn.Linear, torch.nn.Conv2d, torch.nn.LSTM},
                dtype=torch.qint8
            )
            
        elif quantization_type == 'static':
            # 静的量子化（事前にキャリブレーション）
            self.quantized_model = self._apply_static_quantization(calibration_data)
            
        else:
            raise ValueError("サポートされていない量子化タイプです")
        
        self._calculate_compression_stats()
        return self.quantized_model
    
    def _apply_static_quantization(self, calibration_data):
        """静的量子化の適用"""
        # 量子化設定
        self.original_model.qconfig = quant.get_default_qconfig('fbgemm')
        
        # 量子化準備
        model_prepared = quant.prepare(self.original_model.eval())
        
        # キャリブレーション（代表的なデータでの実行）
        if calibration_data is not None:
            with torch.no_grad():
                for data in calibration_data:
                    model_prepared(data)
        
        # 量子化変換
        quantized_model = quant.convert(model_prepared)
        return quantized_model
    
    def apply_qat(self, train_loader, num_epochs=5):
        """量子化対応訓練（QAT: Quantization Aware Training）"""
        
        # QAT用の設定
        self.original_model.qconfig = quant.get_default_qat_qconfig('fbgemm')
        
        # QAT準備
        model_prepared = quant.prepare_qat(self.original_model.train())
        
        # 簡単な訓練ループ
        optimizer = torch.optim.Adam(model_prepared.parameters(), lr=0.001)
        criterion = nn.CrossEntropyLoss()
        
        for epoch in range(num_epochs):
            for batch_idx, (data, target) in enumerate(train_loader):
                optimizer.zero_grad()
                output = model_prepared(data)
                loss = criterion(output, target)
                loss.backward()
                optimizer.step()
                
                if batch_idx % 100 == 0:
                    print(f'Epoch {epoch}, Batch {batch_idx}, Loss: {loss.item():.4f}')
        
        # 量子化変換
        self.quantized_model = quant.convert(model_prepared.eval())
        self._calculate_compression_stats()
        
        return self.quantized_model
    
    def custom_quantization(self, bits=8):
        """カスタム量子化の実装"""
        
        class QuantizedLinear(nn.Module):
            def __init__(self, original_layer, bits=8):
                super(QuantizedLinear, self).__init__()
                self.bits = bits
                self.register_buffer('weight_scale', torch.tensor(1.0))
                self.register_buffer('weight_zero_point', torch.tensor(0))
                
                # 重みの量子化
                self._quantize_weights(original_layer.weight)
                
                if original_layer.bias is not None:
                    self.register_buffer('bias', original_layer.bias.clone())
                else:
                    self.bias = None
            
            def _quantize_weights(self, weights):
                """重みの量子化"""
                # スケールとゼロポイントの計算
                min_val = weights.min()
                max_val = weights.max()
                
                qmin = 0
                qmax = 2 ** self.bits - 1
                
                scale = (max_val - min_val) / (qmax - qmin)
                zero_point = qmin - min_val / scale
                zero_point = torch.clamp(zero_point, qmin, qmax).round()
                
                # 量子化
                quantized_weights = torch.clamp(
                    (weights / scale + zero_point).round(), qmin, qmax
                ) - zero_point
                
                self.register_buffer('quantized_weight', quantized_weights.to(torch.int8))
                self.weight_scale = scale
                self.weight_zero_point = zero_point
            
            def forward(self, x):
                # 量子化された重みを浮動小数点に戻す
                dequantized_weight = (self.quantized_weight.float() + self.weight_zero_point) * self.weight_scale
                return torch.nn.functional.linear(x, dequantized_weight, self.bias)
        
        # モデルの各線形層を量子化版に置換
        quantized_model = self._replace_layers(self.original_model, QuantizedLinear, bits)
        self.quantized_model = quantized_model
        self._calculate_compression_stats()
        
        return quantized_model
    
    def _replace_layers(self, model, new_layer_class, bits):
        """モデル内の層を新しい層に置換"""
        for name, child in model.named_children():
            if isinstance(child, nn.Linear):
                setattr(model, name, new_layer_class(child, bits))
            else:
                self._replace_layers(child, new_layer_class, bits)
        return model
    
    def _calculate_compression_stats(self):
        """圧縮統計の計算"""
        if self.quantized_model is None:
            return
        
        # モデルサイズの比較
        original_size = sum(p.numel() * p.element_size() for p in self.original_model.parameters())
        quantized_size = sum(p.numel() * p.element_size() for p in self.quantized_model.parameters())
        
        compression_ratio = original_size / quantized_size
        
        self.compression_stats = {
            'original_size_mb': original_size / (1024 * 1024),
            'quantized_size_mb': quantized_size / (1024 * 1024),
            'compression_ratio': compression_ratio,
            'size_reduction_percent': (1 - quantized_size/original_size) * 100
        }
        
        print(f"=== 量子化圧縮結果 ===")
        print(f"元のサイズ: {self.compression_stats['original_size_mb']:.2f} MB")
        print(f"量子化後: {self.compression_stats['quantized_size_mb']:.2f} MB")
        print(f"圧縮率: {compression_ratio:.2f}x")
        print(f"サイズ削減: {self.compression_stats['size_reduction_percent']:.1f}%")

# 使用例（概念的）
def demonstrate_quantization():
    # サンプルモデル
    class SimpleModel(nn.Module):
        def __init__(self):
            super(SimpleModel, self).__init__()
            self.fc1 = nn.Linear(784, 256)
            self.fc2 = nn.Linear(256, 128)
            self.fc3 = nn.Linear(128, 10)
        
        def forward(self, x):
            x = torch.relu(self.fc1(x))
            x = torch.relu(self.fc2(x))
            return self.fc3(x)
    
    model = SimpleModel()
    
    # 量子化圧縮器
    compressor = QuantizationCompressor(model)
    
    # 動的量子化
    quantized_model = compressor.apply_post_training_quantization(quantization_type='dynamic')
    
    # カスタム量子化
    custom_quantized = compressor.custom_quantization(bits=4)

# demonstrate_quantization()

プルーニング（Pruning）

構造化・非構造化プルーニング：

import torch.nn.utils.prune as prune

class PruningCompressor:
    def __init__(self, model):
        self.original_model = model
        self.pruned_model = None
        self.pruning_stats = {}
    
    def apply_magnitude_pruning(self, pruning_ratio=0.3, structured=False):
        """重み値に基づくプルーニング"""
        
        self.pruned_model = self.original_model
        
        if structured:
            # 構造化プルーニング（チャネル単位）
            self._apply_structured_pruning(pruning_ratio)
        else:
            # 非構造化プルーニング（重み単位）
            self._apply_unstructured_pruning(pruning_ratio)
        
        self._calculate_sparsity()
        return self.pruned_model
    
    def _apply_unstructured_pruning(self, pruning_ratio):
        """非構造化プルーニング"""
        
        print(f"=== 非構造化プルーニング（比率: {pruning_ratio}） ===")
        
        for name, module in self.pruned_model.named_modules():
            if isinstance(module, (nn.Linear, nn.Conv2d)):
                # 重みの絶対値に基づくプルーニング
                prune.l1_unstructured(module, name='weight', amount=pruning_ratio)
                
                # バイアスがある場合はバイアスもプルーニング
                if hasattr(module, 'bias') and module.bias is not None:
                    prune.l1_unstructured(module, name='bias', amount=pruning_ratio)
                
                print(f"プルーニング適用: {name}")
    
    def _apply_structured_pruning(self, pruning_ratio):
        """構造化プルーニング"""
        
        print(f"=== 構造化プルーニング（比率: {pruning_ratio}） ===")
        
        for name, module in self.pruned_model.named_modules():
            if isinstance(module, nn.Conv2d):
                # フィルタ単位でのプルーニング
                prune.ln_structured(module, name='weight', amount=pruning_ratio, n=2, dim=0)
                print(f"構造化プルーニング適用（フィルタ単位）: {name}")
                
            elif isinstance(module, nn.Linear):
                # ニューロン単位でのプルーニング
                prune.ln_structured(module, name='weight', amount=pruning_ratio, n=2, dim=0)
                print(f"構造化プルーニング適用（ニューロン単位）: {name}")
    
    def apply_gradual_pruning(self, train_loader, initial_sparsity=0.0, final_sparsity=0.8, num_epochs=10):
        """段階的プルーニング"""
        
        print(f"=== 段階的プルーニング ===")
        print(f"初期スパース性: {initial_sparsity}")
        print(f"最終スパース性: {final_sparsity}")
        
        self.pruned_model = self.original_model
        
        # プルーニングスケジューラー
        def compute_sparsity(epoch, num_epochs, initial, final):
            if epoch >= num_epochs:
                return final
            return initial + (final - initial) * (epoch / num_epochs)
        
        optimizer = torch.optim.Adam(self.pruned_model.parameters(), lr=0.001)
        criterion = nn.CrossEntropyLoss()
        
        for epoch in range(num_epochs):
            # 現在のスパース性を計算
            current_sparsity = compute_sparsity(epoch, num_epochs, initial_sparsity, final_sparsity)
            
            # プルーニングの適用
            for name, module in self.pruned_model.named_modules():
                if isinstance(module, (nn.Linear, nn.Conv2d)):
                    prune.l1_unstructured(module, name='weight', amount=current_sparsity)
            
            # 訓練
            for batch_idx, (data, target) in enumerate(train_loader):
                optimizer.zero_grad()
                output = self.pruned_model(data)
                loss = criterion(output, target)
                loss.backward()
                optimizer.step()
                
                if batch_idx % 100 == 0:
                    break  # 簡略化のため1バッチのみ
            
            print(f"Epoch {epoch}: スパース性 {current_sparsity:.3f}")
        
        self._calculate_sparsity()
        return self.pruned_model
    
    def apply_lottery_ticket_pruning(self, train_loader, pruning_iterations=5, pruning_ratio=0.2):
        """宝くじ仮説に基づくプルーニング"""
        
        print(f"=== 宝くじ仮説プルーニング ===")
        
        # 初期重みを保存
        initial_weights = {}
        for name, param in self.original_model.named_parameters():
            initial_weights[name] = param.clone()
        
        current_model = self.original_model
        
        for iteration in range(pruning_iterations):
            print(f"反復 {iteration + 1}/{pruning_iterations}")
            
            # 1. 現在のモデルを訓練
            optimizer = torch.optim.Adam(current_model.parameters(), lr=0.001)
            criterion = nn.CrossEntropyLoss()
            
            # 簡略化された訓練（実際には完全な訓練が必要）
            for epoch in range(2):
                for batch_idx, (data, target) in enumerate(train_loader):
                    optimizer.zero_grad()
                    output = current_model(data)
                    loss = criterion(output, target)
                    loss.backward()
                    optimizer.step()
                    
                    if batch_idx >= 5:  # 簡略化
                        break
            
            # 2. プルーニング（重み値の小さいものを除去）
            for name, module in current_model.named_modules():
                if isinstance(module, (nn.Linear, nn.Conv2d)):
                    prune.l1_unstructured(module, name='weight', amount=pruning_ratio)
            
            # 3. 初期重みに戻す（プルーニングマスクは維持）
            with torch.no_grad():
                for name, param in current_model.named_parameters():
                    if 'weight_orig' in name:  # プルーニングされた重み
                        original_name = name.replace('_orig', '')
                        if original_name in initial_weights:
                            param.copy_(initial_weights[original_name])
        
        self.pruned_model = current_model
        self._calculate_sparsity()
        
        return self.pruned_model
    
    def _calculate_sparsity(self):
        """スパース性の計算"""
        if self.pruned_model is None:
            return
        
        total_params = 0
        pruned_params = 0
        
        for name, module in self.pruned_model.named_modules():
            if isinstance(module, (nn.Linear, nn.Conv2d)):
                # プルーニングマスクが存在するかチェック
                if hasattr(module, 'weight_mask'):
                    mask = module.weight_mask
                    total_params += mask.numel()
                    pruned_params += (mask == 0).sum().item()
                else:
                    # プルーニングされていない場合
                    total_params += module.weight.numel()
        
        sparsity = pruned_params / total_params if total_params > 0 else 0
        
        self.pruning_stats = {
            'total_parameters': total_params,
            'pruned_parameters': pruned_params,
            'remaining_parameters': total_params - pruned_params,
            'sparsity': sparsity,
            'compression_ratio': 1 / (1 - sparsity) if sparsity < 1 else float('inf')
        }
        
        print(f"=== プルーニング結果 ===")
        print(f"総パラメータ数: {total_params:,}")
        print(f"除去されたパラメータ: {pruned_params:,}")
        print(f"残存パラメータ: {total_params - pruned_params:,}")
        print(f"スパース性: {sparsity:.3f}")
        print(f"圧縮率: {self.pruning_stats['compression_ratio']:.2f}x")

def demonstrate_pruning():
    # サンプルモデル
    class CNNModel(nn.Module):
        def __init__(self):
            super(CNNModel, self).__init__()
            self.conv1 = nn.Conv2d(1, 32, 3, 1)
            self.conv2 = nn.Conv2d(32, 64, 3, 1)
            self.fc1 = nn.Linear(9216, 128)
            self.fc2 = nn.Linear(128, 10)
        
        def forward(self, x):
            x = torch.relu(self.conv1(x))
            x = torch.relu(self.conv2(x))
            x = torch.flatten(x, 1)
            x = torch.relu(self.fc1(x))
            return self.fc2(x)
    
    model = CNNModel()
    
    # プルーニング圧縮器
    compressor = PruningCompressor(model)
    
    # 重み値プルーニング
    pruned_model = compressor.apply_magnitude_pruning(pruning_ratio=0.5, structured=False)

# demonstrate_pruning()

知識蒸留（Knowledge Distillation）

教師-生徒モデル学習：

class KnowledgeDistillationCompressor:
    def __init__(self, teacher_model, student_model):
        self.teacher_model = teacher_model
        self.student_model = student_model
        self.distillation_stats = {}
    
    def distill_knowledge(self, train_loader, num_epochs=10, temperature=4.0, alpha=0.7):
        """知識蒸留による圧縮"""
        
        print(f"=== 知識蒸留 ===")
        print(f"温度パラメータ: {temperature}")
        print(f"蒸留重み: {alpha}")
        
        # 教師モデルを評価モードに
        self.teacher_model.eval()
        
        # 生徒モデルの最適化器
        optimizer = torch.optim.Adam(self.student_model.parameters(), lr=0.001)
        
        # 損失関数
        hard_loss_fn = nn.CrossEntropyLoss()
        soft_loss_fn = nn.KLDivLoss(reduction='batchmean')
        
        for epoch in range(num_epochs):
            epoch_hard_loss = 0
            epoch_soft_loss = 0
            epoch_total_loss = 0
            
            for batch_idx, (data, target) in enumerate(train_loader):
                optimizer.zero_grad()
                
                # 教師モデルの出力（勾配計算なし）
                with torch.no_grad():
                    teacher_outputs = self.teacher_model(data)
                
                # 生徒モデルの出力
                student_outputs = self.student_model(data)
                
                # ハード損失（正解ラベルとの損失）
                hard_loss = hard_loss_fn(student_outputs, target)
                
                # ソフト損失（教師の出力との損失）
                teacher_soft = F.softmax(teacher_outputs / temperature, dim=1)
                student_soft = F.log_softmax(student_outputs / temperature, dim=1)
                soft_loss = soft_loss_fn(student_soft, teacher_soft) * (temperature ** 2)
                
                # 総損失
                total_loss = alpha * soft_loss + (1 - alpha) * hard_loss
                
                total_loss.backward()
                optimizer.step()
                
                # 統計更新
                epoch_hard_loss += hard_loss.item()
                epoch_soft_loss += soft_loss.item()
                epoch_total_loss += total_loss.item()
                
                if batch_idx % 100 == 0:
                    print(f"Epoch {epoch}, Batch {batch_idx}: "
                          f"Hard Loss: {hard_loss.item():.4f}, "
                          f"Soft Loss: {soft_loss.item():.4f}")
                
                # 簡略化のため少数バッチで終了
                if batch_idx >= 10:
                    break
            
            avg_hard_loss = epoch_hard_loss / min(len(train_loader), 11)
            avg_soft_loss = epoch_soft_loss / min(len(train_loader), 11)
            avg_total_loss = epoch_total_loss / min(len(train_loader), 11)
            
            print(f"Epoch {epoch} 完了: "
                  f"Avg Hard Loss: {avg_hard_loss:.4f}, "
                  f"Avg Soft Loss: {avg_soft_loss:.4f}, "
                  f"Avg Total Loss: {avg_total_loss:.4f}")
        
        self._calculate_compression_stats()
        return self.student_model
    
    def progressive_distillation(self, train_loader, intermediate_sizes, num_epochs_per_stage=5):
        """段階的知識蒸留"""
        
        print(f"=== 段階的知識蒸留 ===")
        print(f"中間サイズ: {intermediate_sizes}")
        
        current_teacher = self.teacher_model
        
        for stage, size in enumerate(intermediate_sizes):
            print(f"\nステージ {stage + 1}: 中間サイズ {size}")
            
            # 中間サイズの生徒モデルを作成
            intermediate_student = self._create_intermediate_model(size)
            
            # 知識蒸留
            distiller = KnowledgeDistillationCompressor(current_teacher, intermediate_student)
            distilled_model = distiller.distill_knowledge(
                train_loader, num_epochs=num_epochs_per_stage
            )
            
            # 次のステージの教師として使用
            current_teacher = distilled_model
        
        # 最終的な生徒モデルに蒸留
        final_distiller = KnowledgeDistillationCompressor(current_teacher, self.student_model)
        final_model = final_distiller.distill_knowledge(train_loader, num_epochs=num_epochs_per_stage)
        
        self._calculate_compression_stats()
        return final_model
    
    def attention_based_distillation(self, train_loader, num_epochs=10):
        """アテンション転移による知識蒸留"""
        
        print(f"=== アテンション転移蒸留 ===")
        
        optimizer = torch.optim.Adam(self.student_model.parameters(), lr=0.001)
        
        # 損失関数
        task_loss_fn = nn.CrossEntropyLoss()
        attention_loss_fn = nn.MSELoss()
        
        for epoch in range(num_epochs):
            for batch_idx, (data, target) in enumerate(train_loader):
                optimizer.zero_grad()
                
                # 教師モデルの出力（アテンション重みも取得）
                with torch.no_grad():
                    teacher_outputs, teacher_attention = self._forward_with_attention(
                        self.teacher_model, data
                    )
                
                # 生徒モデルの出力
                student_outputs, student_attention = self._forward_with_attention(
                    self.student_model, data
                )
                
                # タスク損失
                task_loss = task_loss_fn(student_outputs, target)
                
                # アテンション転移損失
                attention_loss = attention_loss_fn(student_attention, teacher_attention)
                
                # 総損失
                total_loss = task_loss + 0.5 * attention_loss
                
                total_loss.backward()
                optimizer.step()
                
                if batch_idx % 100 == 0:
                    print(f"Epoch {epoch}, Batch {batch_idx}: "
                          f"Task Loss: {task_loss.item():.4f}, "
                          f"Attention Loss: {attention_loss.item():.4f}")
                
                if batch_idx >= 10:  # 簡略化
                    break
        
        return self.student_model
    
    def _forward_with_attention(self, model, data):
        """アテンション重みとともに順伝播"""
        # 実際の実装では、モデルの中間層からアテンション重みを抽出
        # ここでは概念的な実装
        outputs = model(data)
        
        # ダミーのアテンション重み
        attention_weights = torch.randn(data.size(0), 64, 64)
        
        return outputs, attention_weights
    
    def _create_intermediate_model(self, size):
        """中間サイズのモデル作成"""
        # 実際の実装では、指定されたサイズのアーキテクチャを作成
        # ここでは概念的な実装
        class IntermediateModel(nn.Module):
            def __init__(self, hidden_size):
                super(IntermediateModel, self).__init__()
                self.fc1 = nn.Linear(784, hidden_size)
                self.fc2 = nn.Linear(hidden_size, hidden_size // 2)
                self.fc3 = nn.Linear(hidden_size // 2, 10)
            
            def forward(self, x):
                x = x.view(x.size(0), -1)
                x = torch.relu(self.fc1(x))
                x = torch.relu(self.fc2(x))
                return self.fc3(x)
        
        return IntermediateModel(size)
    
    def _calculate_compression_stats(self):
        """圧縮統計の計算"""
        # 教師モデルのサイズ
        teacher_params = sum(p.numel() for p in self.teacher_model.parameters())
        teacher_size = sum(p.numel() * p.element_size() for p in self.teacher_model.parameters())
        
        # 生徒モデルのサイズ
        student_params = sum(p.numel() for p in self.student_model.parameters())
        student_size = sum(p.numel() * p.element_size() for p in self.student_model.parameters())
        
        compression_ratio = teacher_size / student_size
        param_ratio = teacher_params / student_params
        
        self.distillation_stats = {
            'teacher_parameters': teacher_params,
            'student_parameters': student_params,
            'teacher_size_mb': teacher_size / (1024 * 1024),
            'student_size_mb': student_size / (1024 * 1024),
            'compression_ratio': compression_ratio,
            'parameter_ratio': param_ratio,
            'size_reduction_percent': (1 - student_size/teacher_size) * 100
        }
        
        print(f"=== 知識蒸留圧縮結果 ===")
        print(f"教師モデル: {teacher_params:,} パラメータ, {self.distillation_stats['teacher_size_mb']:.2f} MB")
        print(f"生徒モデル: {student_params:,} パラメータ, {self.distillation_stats['student_size_mb']:.2f} MB")
        print(f"圧縮率: {compression_ratio:.2f}x")
        print(f"パラメータ削減: {param_ratio:.2f}x")
        print(f"サイズ削減: {self.distillation_stats['size_reduction_percent']:.1f}%")

def demonstrate_knowledge_distillation():
    # 教師モデル（大規模）
    class TeacherModel(nn.Module):
        def __init__(self):
            super(TeacherModel, self).__init__()
            self.fc1 = nn.Linear(784, 1024)
            self.fc2 = nn.Linear(1024, 512)
            self.fc3 = nn.Linear(512, 256)
            self.fc4 = nn.Linear(256, 10)
        
        def forward(self, x):
            x = x.view(x.size(0), -1)
            x = torch.relu(self.fc1(x))
            x = torch.relu(self.fc2(x))
            x = torch.relu(self.fc3(x))
            return self.fc4(x)
    
    # 生徒モデル（小規模）
    class StudentModel(nn.Module):
        def __init__(self):
            super(StudentModel, self).__init__()
            self.fc1 = nn.Linear(784, 128)
            self.fc2 = nn.Linear(128, 64)
            self.fc3 = nn.Linear(64, 10)
        
        def forward(self, x):
            x = x.view(x.size(0), -1)
            x = torch.relu(self.fc1(x))
            x = torch.relu(self.fc2(x))
            return self.fc3(x)
    
    teacher = TeacherModel()
    student = StudentModel()
    
    # 知識蒸留圧縮器
    distiller = KnowledgeDistillationCompressor(teacher, student)
    
    # ダミーの訓練データローダー
    train_data = torch.randn(100, 1, 28, 28)
    train_labels = torch.randint(0, 10, (100,))
    train_dataset = torch.utils.data.TensorDataset(train_data, train_labels)
    train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=16, shuffle=True)
    
    # 知識蒸留実行
    compressed_model = distiller.distill_knowledge(train_loader, num_epochs=3)

# demonstrate_knowledge_distillation()

活用事例・ユースケース

モデル圧縮は現代のAI実用化において重要な役割を果たしています。

モバイルアプリケーション

スマートフォンでの画像認識、音声認識、翻訳アプリの実現。

IoTデバイス

センサーデータ分析、エッジ推論、リアルタイム監視システム。

自動運転

車載システムでの物体検出、経路判断、安全性評価。

医療機器

ポータブル診断装置、ウェアラブルデバイス、遠隔医療。

クラウドサービス

推論コストの削減、応答速度の向上、エネルギー効率の改善。

学ぶためのおすすめリソース

書籍

「Efficient Deep Learning」（Gaurav Menghani）、「TinyML」（Pete Warden）

オンラインコース

Stanford「CS330: Deep Multi-Task and Meta Learning」、MIT「6.S191: Introduction to Deep Learning」

実装フレームワーク

PyTorch、TensorFlow Lite、ONNX、OpenVINO、TensorRT

論文

「DistilBERT」、「MobilNet」、「BERT蒸留」、「Lottery Ticket Hypothesis」

よくある質問（FAQ）

Q. どの圧縮手法が最も効果的か？
A. アプリケーションとモデルによって異なります。多くの場合、複数の手法を組み合わせることで最良の結果が得られます。

Q. 圧縮により性能はどの程度低下するか？
A. 適切な手法を用いれば、10-50倍の圧縮でも性能低下を5%以下に抑えることが可能です。

Q. リアルタイム推論での効果は？
A. 圧縮により推論速度が2-10倍向上し、メモリ使用量も大幅に削減できます。

関連キーワード

量子化、プルーニング、知識蒸留、エッジAI、軽量化、最適化

まとめ

モデル圧縮は、高性能なAIモデルを実用的な環境で活用するための重要な技術です。量子化、プルーニング、知識蒸留など様々な手法を組み合わせることで、性能を維持しながら大幅なサイズ削減が可能です。エッジデバイス、モバイル環境、リアルタイム推論など、計算資源が制限された環境でのAI活用を実現し、AI技術の民主化と普及に貢献します。今後も、より効率的で実用的な圧縮技術の発展により、AIがより身近で持続可能な技術となることが期待されます。