lora_utils/fp8_optimization_utils.py

"""
FramePack-eichi FP8最適化モジュール
モデルを8ビット浮動小数点形式に量子化して、メモリ使用量と処理速度を最適化するモジュールです。
FramePack-LoRAReadyから移植されています。

基本的な特徴:
- E4M3およびE5M2 FP8フォーマットのサポート
- 異なるGPUアーキテクチャに対する最適化
- モンキーパッチによる透過的な統合
- RTX 40シリーズ向けのscaled_mm最適化対応
"""

import os
import torch

# 警告メッセージが表示されたかを追跡するフラグ
FP8_E4M3_WARNING_SHOWN = False
FP8_DIMENSIONS_WARNING_SHOWN = False
import torch.nn as nn
import torch.nn.functional as F
from tqdm import tqdm

# 国際化対応
from locales.i18n_extended import translate

def calculate_fp8_maxval(exp_bits=4, mantissa_bits=3, sign_bits=1):
    """
    FP8形式で表現可能な最大値を計算
    デフォルトはE4M3形式（4ビット指数部、3ビット仮数部、1ビット符号部）

    Args:
        exp_bits (int): 指数部のビット数
        mantissa_bits (int): 仮数部のビット数
        sign_bits (int): 符号部のビット数（0または1）

    Returns:
        float: FP8形式で表現可能な最大値
    """
    assert exp_bits + mantissa_bits + sign_bits == 8, translate("合計ビット数は8でなければなりません")

    # 指数バイアスを計算
    bias = 2 ** (exp_bits - 1) - 1

    # 最大仮数値を計算
    mantissa_max = 1.0
    for i in range(mantissa_bits - 1):
        mantissa_max += 2 ** -(i + 1)

    # 最大値を計算
    max_value = mantissa_max * (2 ** (2**exp_bits - 1 - bias))

    return max_value

def quantize_tensor_to_fp8(tensor, scale, exp_bits=4, mantissa_bits=3, sign_bits=1, max_value=None, min_value=None):
    """
    テンソルをFP8形式に量子化する

    Args:
        tensor (torch.Tensor): 量子化するテンソル
        scale (float or torch.Tensor): スケールファクター
        exp_bits (int): 指数部のビット数
        mantissa_bits (int): 仮数部のビット数
        sign_bits (int): 符号部のビット数
        max_value (float, optional): 最大値（Noneの場合は自動計算）
        min_value (float, optional): 最小値（Noneの場合は自動計算）

    Returns:
        tuple: (量子化されたテンソル, スケールファクター)
    """
    # スケーリングされたテンソルを作成
    scaled_tensor = tensor / scale

    # FP8パラメータを計算
    bias = 2 ** (exp_bits - 1) - 1

    if max_value is None:
        # 最大値と最小値を計算
        max_value = calculate_fp8_maxval(exp_bits, mantissa_bits, sign_bits)
        min_value = -max_value if sign_bits > 0 else 0.0

    # テンソルを範囲内に制限
    clamped_tensor = torch.clamp(scaled_tensor, min_value, max_value)

    # 量子化プロセス
    abs_values = torch.abs(clamped_tensor)
    nonzero_mask = abs_values > 0

    # logFスケールを計算（非ゼロ要素のみ）
    log_scales = torch.zeros_like(clamped_tensor)
    if nonzero_mask.any():
        log_scales[nonzero_mask] = torch.floor(torch.log2(abs_values[nonzero_mask]) + bias).detach()

    # logスケールを制限し、量子化係数を計算
    log_scales = torch.clamp(log_scales, min=1.0)
    quant_factor = 2.0 ** (log_scales - mantissa_bits - bias)

    # 量子化と逆量子化
    quantized = torch.round(clamped_tensor / quant_factor) * quant_factor

    return quantized, scale

def optimize_state_dict_with_fp8_on_the_fly(
    model_files,
    calc_device,
    target_layer_keys=None,
    exclude_layer_keys=None,
    exp_bits=4,
    mantissa_bits=3,
    move_to_device=False,
    weight_hook=None,
):
    """
    モデルの状態辞書内の線形レイヤーの重みをFP8形式に最適化

    Args:
        model_files (list): 最適化するモデルファイルのリスト（読み込みながら更新）
        calc_device (str): テンソルを量子化するデバイス
        target_layer_keys (list, optional): 対象とするレイヤーキーのパターン（Noneの場合はすべての線形レイヤー）
        exclude_layer_keys (list, optional): 除外するレイヤーキーのパターン
        exp_bits (int): 指数部のビット数
        mantissa_bits (int): 仮数部のビット数
        move_to_device (bool): 最適化されたテンソルを計算デバイスに移動するかどうか
        weight_hook (callable, optional): 重みのフック関数（Noneの場合は使用しない）、FP8最適化前に、FP8最適化の有無に関係なくすべての重みに適用される。

    Returns:
        dict: FP8最適化された状態辞書
    """
    # FP8データ型の選択
    if exp_bits == 4 and mantissa_bits == 3:
        fp8_dtype = torch.float8_e4m3fn
    elif exp_bits == 5 and mantissa_bits == 2:
        fp8_dtype = torch.float8_e5m2
    else:
        raise ValueError(translate("サポートされていないFP8形式: E{0}M{1}").format(exp_bits, mantissa_bits))

    # FP8の最大値を計算
    max_value = calculate_fp8_maxval(exp_bits, mantissa_bits)
    min_value = -max_value  # この関数は符号付きFP8のみサポート

    # 最適化された状態辞書を作成する

    def is_target_key(key):
        # 重みキーが対象パターンに一致し、除外パターンに一致しないかを確認
        is_target = (target_layer_keys is None or any(pattern in key for pattern in target_layer_keys)) and key.endswith(".weight")
        is_excluded = exclude_layer_keys is not None and any(pattern in key for pattern in exclude_layer_keys)
        is_target = is_target and not is_excluded
        return is_target

    # 最適化されたレイヤーのカウンター
    optimized_count = 0
    
    # それぞれのモデルファイルを処理        
    from lora_utils.safetensors_utils import MemoryEfficientSafeOpen

    state_dict = {}
    for model_file in model_files:
        with MemoryEfficientSafeOpen(model_file) as f:
            keys = f.keys()
            for key in tqdm(keys, desc=f"Loading {os.path.basename(model_file)}", unit="key"):
                value = f.get_tensor(key)
                if weight_hook is not None:
                    # 重みフックが指定されている場合、フックを適用
                    value = weight_hook(key, value)

                if not is_target_key(key):
                    state_dict[key] = value
                    continue

                # 元のデバイスとデータ型を保存
                original_device = value.device
                original_dtype = value.dtype

                # 計算デバイスに移動
                if calc_device is not None:
                    value = value.to(calc_device)

                # スケールファクターを計算
                scale = torch.max(torch.abs(value.flatten())) / max_value

                # 重みをFP8に量子化
                quantized_weight, _ = quantize_tensor_to_fp8(value, scale, exp_bits, mantissa_bits, 1, max_value, min_value)

                # 重みに元のキー、スケールに新しいキーを使用
                fp8_key = key
                scale_key = key.replace(".weight", ".scale_weight")

                # FP8データ型に変換
                quantized_weight = quantized_weight.to(fp8_dtype)

                # デバイスの指定がない場合は元のデバイスに戻す
                if not move_to_device:
                    quantized_weight = quantized_weight.to(original_device)

                # スケールテンソルを作成
                scale_tensor = torch.tensor([scale], dtype=original_dtype, device=quantized_weight.device)

                # 状態辞書に追加
                state_dict[fp8_key] = quantized_weight
                state_dict[scale_key] = scale_tensor

                optimized_count += 1

                # 計算デバイスのメモリを定期的に解放
                if calc_device is not None  and optimized_count % 10 == 0:
                    torch.cuda.empty_cache()

    print(translate("最適化された線形レイヤー数: {0}").format(optimized_count))
    return state_dict

def fp8_linear_forward_patch(self: nn.Linear, x, use_scaled_mm=False, max_value=None):
    """
    FP8重みを持つ線形レイヤー用のパッチ適用済みフォワードメソッド

    Args:
        self: 線形レイヤーのインスタンス
        x (torch.Tensor): 入力テンソル
        use_scaled_mm (bool): FP8線形レイヤーに scaled_mm を使用するかどうか（SM 8.9+、RTX 40シリーズが必要）
        max_value (float): FP8量子化の最大値（Noneの場合、入力テンソルに量子化は適用されない）

    Returns:
        torch.Tensor: 線形変換の結果
    """
    if use_scaled_mm:
        # scaled_mmを使用する場合（RTX 40シリーズのGPUでのみ動作）
        input_dtype = x.dtype
        original_weight_dtype = self.scale_weight.dtype
        weight_dtype = self.weight.dtype
        target_dtype = torch.float8_e5m2

        # E4M3FNでない場合は通常方式にフォールバック
        # scaled_mmはFP8でもE4M3FN形式のみ対応しているため、他の形式では使用不可
        global FP8_E4M3_WARNING_SHOWN
        if weight_dtype != torch.float8_e4m3fn:
            if not FP8_E4M3_WARNING_SHOWN:
                print(translate("警告: scaled_mmはFP8 E4M3FN形式を必要としますが、{weight_dtype}が検出されました。通常方式にフォールバックします。").format(weight_dtype=weight_dtype))
                FP8_E4M3_WARNING_SHOWN = True
            # 通常の方式にフォールバック
            return fp8_linear_forward_patch(self, x, False, max_value)

        # 入力テンソルの次元チェック
        # scaled_mmは3次元テンソル（batch_size, seq_len, hidden_dim）を想定しているため、それ以外では機能しない
        global FP8_DIMENSIONS_WARNING_SHOWN
        if x.ndim != 3:
            if not FP8_DIMENSIONS_WARNING_SHOWN:
                print(translate("警告: scaled_mmは3次元入力が必要ですが、{0}次元が検出されました。通常方式にフォールバックします。").format(x.ndim))
                FP8_DIMENSIONS_WARNING_SHOWN = True
            # 通常の方式にフォールバック
            return fp8_linear_forward_patch(self, x, False, max_value)

        if max_value is None:
            # 入力の量子化なし
            scale_x = torch.tensor(1.0, dtype=torch.float32, device=x.device)
        else:
            # 入力テンソルのスケールファクターを計算
            scale_x = (torch.max(torch.abs(x.flatten())) / max_value).to(torch.float32)

            # 入力テンソルをFP8に量子化（メモリを大量に消費する可能性あり）
            x, _ = quantize_tensor_to_fp8(x, scale_x, 5, 2, 1, max_value, -max_value)

        # テンソルの形状を変換
        original_shape = x.shape
        x = x.reshape(-1, x.shape[2]).to(target_dtype)

        # 重みを転置
        weight = self.weight.t()
        scale_weight = self.scale_weight.to(torch.float32)

        # scaled_mmを使用して計算（バイアス有無で処理を分ける）
        if self.bias is not None:
            # バイアスがある場合、float32はサポートされていません
            o = torch._scaled_mm(x, weight, out_dtype=original_weight_dtype, bias=self.bias, scale_a=scale_x, scale_b=scale_weight)
        else:
            o = torch._scaled_mm(x, weight, out_dtype=input_dtype, scale_a=scale_x, scale_b=scale_weight)

        # 元の形状に戻して返す
        return o.reshape(original_shape[0], original_shape[1], -1).to(input_dtype)
    else:
        # 通常の方式（重みを逆量子化して計算）
        original_dtype = self.scale_weight.dtype
        dequantized_weight = self.weight.to(original_dtype) * self.scale_weight

        # 線形変換を実行
        if self.bias is not None:
            output = F.linear(x, dequantized_weight, self.bias)
        else:
            output = F.linear(x, dequantized_weight)

        return output

def apply_fp8_monkey_patch(model, optimized_state_dict, use_scaled_mm=False):
    """
    FP8最適化された状態辞書を使用してモデルにモンキーパッチを適用

    Args:
        model (nn.Module): パッチを適用するモデルインスタンス
        optimized_state_dict (dict): FP8最適化された状態辞書
        use_scaled_mm (bool): FP8線形レイヤーに scaled_mm を使用するかどうか（SM 8.9+、RTX 40シリーズが必要）

    Returns:
        nn.Module: パッチが適用されたモデル（同じインスタンスをインプレースで修正）
    """
    # 入力テンソルの量子化には使用しない（デフォルト）
    max_value = None

    # スケールキーを見つけてFP8最適化されたレイヤーを特定
    scale_keys = [k for k in optimized_state_dict.keys() if k.endswith(".scale_weight")]

    # パッチ適用済みモジュールのパスを設定
    patched_module_paths = set()
    for scale_key in scale_keys:
        # スケールキーからモジュールパスを抽出（".scale_weight"を削除）
        module_path = scale_key.rsplit(".scale_weight", 1)[0]
        patched_module_paths.add(module_path)

    patched_count = 0

    # FP8重みを持つ各レイヤーにモンキーパッチを適用
    for name, module in model.named_modules():
        # このモジュールに対応するスケール重みがあるかチェック
        has_scale = name in patched_module_paths

        # FP8スケールを持つ線形レイヤーにパッチを適用
        if isinstance(module, nn.Linear) and has_scale:
            # スケール重みをバッファとして登録（状態辞書をロードするため）
            module.register_buffer("scale_weight", torch.tensor(1.0, dtype=module.weight.dtype))

            # パッチ適用済みのフォワードメソッドを作成
            def new_forward(self, x):
                return fp8_linear_forward_patch(self, x, use_scaled_mm, max_value)

            # メソッドをモジュールにバインド
            module.forward = new_forward.__get__(module, type(module))

            patched_count += 1

    print(translate("モンキーパッチ適用済みの線形レイヤー数: {0}").format(patched_count))
    # モデルにFP8適用済みフラグを設定
    model._fp8_optimized = True
    return model

def check_fp8_support():
    """
    FP8サポートをチェックする関数

    Returns:
        tuple: (E4M3サポート, E5M2サポート, scaled_mmサポート)
    """
    # FP8サポートのチェック
    has_e4m3 = hasattr(torch, 'float8_e4m3fn')
    has_e5m2 = hasattr(torch, 'float8_e5m2')

    # scaled_mm サポートのチェック
    has_scaled_mm = hasattr(torch, '_scaled_mm')

    if has_e4m3 and has_e5m2:
        if has_scaled_mm:
            print(translate("RTX 40シリーズのGPUでFP8の高速化が可能です"))
    else:
        print(translate("警告: FP8サポートが検出されませんでした。PyTorch 2.1以上が必要です"))

    return has_e4m3, has_e5m2, has_scaled_mm

def reset_fp8_warning_flags():
    """
    FP8警告フラグをリセットする関数
    各生成処理の開始時に呼び出すことで、生成ごとに警告を表示できるようにする
    """
    global FP8_E4M3_WARNING_SHOWN, FP8_DIMENSIONS_WARNING_SHOWN
    FP8_E4M3_WARNING_SHOWN = False
    FP8_DIMENSIONS_WARNING_SHOWN = False


def reset_warning_flags():
    """
    警告フラグをリセットする関数（新しい生成プロセスが開始されるたびに呼び出す）
    """
    global FP8_E4M3_WARNING_SHOWN, FP8_DIMENSIONS_WARNING_SHOWN
    FP8_E4M3_WARNING_SHOWN = False
    FP8_DIMENSIONS_WARNING_SHOWN = False