FramePack-eichiをARC B580で動かす(改)（Windows編）

Amazonのアソシエイトとして、当ブログは適格販売により収入を得ています。

2025/5/3に記事を書き直しました。

前回、Ubuntu編をやりましたが今回はWindows編やっていきます。
といってもいつものごとくUbuntu編とあまり変わりません。
以下が手順です。

Microsoft visual C++ 再頒布可能パッケージのインストール
gitをインストール
minicondaをインストール
FramePack-eichiをダウンロード
本家FramePackのダウンロード
FramePack-eichiの「webui」の中身を「FramePack」以下に配置
「FramePack\diffusers_helper」のmemory.pyの書き換え
「本家FramePack」を起動してモデルデータを取得する
「eichi」入りFramePackの起動

stable diffusionなどをインストーする場合はいつも必要になるMicrosoft visual C++ 再頒布可能パッケージとgitとminicondaをインストールする以外はUbuntuとあまり変わりません。
Windowsの方が手動でやらなければならない分面倒ってことくらいです。

バッチファイルが作れる人は作ってしまった方が楽だと思いますが、自分コマンドプロンプト書けないので（覚える気がないので）動作確認したらそれで終わりにしてしまいます。

環境を作る

１，２，３の手順は以前の記事を参考にしてください。
minicondaをインストールして「Anaconda Prompt」を立ち上げた状態から

conda create -n test_env python=3.12
conda activate test_env
git clone https://github.com/lllyasviel/FramePack.git framepack

で本家FramePackをダウンロードしておきます。

FramePack-eichiをダウンロード

続いてFramePack-eichiをダウンロードします。

git clone https://github.com/git-ai-code/FramePack-eichi.git framepack-eichi

ダウンロードしたら一旦「Anaconda Prompt」を閉じます。
閉じたら以下のようにエクスプローラでダウンロードしたフォルダまで移動します。

同じようにして「C:\Users\(ユーザー名)\framepack」もウィンドウを開いておきます。

memory.pyの書き換え

「C:\Users\(ユーザー名)\framepack\diffusers_helper」内の「memory.py」を開きます。

削除した空白に以下のスクリプトをコピペします。

# By lllyasviel (XPU対応版)

import torch

cpu = torch.device('cpu')
gpu = torch.device(f"xpu:{torch.xpu.current_device()}")
gpu_complete_modules = []

class DynamicSwapInstaller:
    @staticmethod
    def _install_module(module: torch.nn.Module, **kwargs):
        original_class = module.__class__
        module.__dict__['forge_backup_original_class'] = original_class

        def hacked_get_attr(self, name: str):
            if '_parameters' in self.__dict__:
                _parameters = self.__dict__['_parameters']
                if name in _parameters:
                    p = _parameters[name]
                    if p is None:
                        return None
                    if isinstance(p, torch.nn.Parameter):
                        return torch.nn.Parameter(p.to(**kwargs), requires_grad=p.requires_grad)
                    else:
                        return p.to(**kwargs)
            if '_buffers' in self.__dict__:
                _buffers = self.__dict__['_buffers']
                if name in _buffers:
                    return _buffers[name].to(**kwargs)
            return super(original_class, self).__getattr__(name)

        module.__class__ = type('DynamicSwap_' + original_class.__name__, (original_class,), {
            '__getattr__': hacked_get_attr,
        })

        return

    @staticmethod
    def _uninstall_module(module: torch.nn.Module):
        if 'forge_backup_original_class' in module.__dict__:
            module.__class__ = module.__dict__.pop('forge_backup_original_class')
        return

    @staticmethod
    def install_model(model: torch.nn.Module, **kwargs):
        for m in model.modules():
            DynamicSwapInstaller._install_module(m, **kwargs)
        return

    @staticmethod
    def uninstall_model(model: torch.nn.Module):
        for m in model.modules():
            DynamicSwapInstaller._uninstall_module(m)
        return


def fake_diffusers_current_device(model: torch.nn.Module, target_device: torch.device):
    if hasattr(model, 'scale_shift_table'):
        model.scale_shift_table.data = model.scale_shift_table.data.to(target_device)
        return

    for _, p in model.named_modules():
        if hasattr(p, 'weight'):
            p.to(target_device)
            return


def get_cuda_free_memory_gb(device=None):
    if device is None:
        device = gpu

    if device.type == "xpu":
        try:
            props = torch.xpu.get_device_properties(device)
            total_memory = props.total_memory
            allocated = torch.xpu.memory_allocated(device)
            free = total_memory - allocated
            return free / (1024 ** 3)
        except Exception as e:
            print("[Warning] Failed to get XPU memory info:", e)
            return 0

    # fallback for CUDA (if you run on CUDA system)
    if device.type == "cuda":
        try:
            memory_stats = torch.cuda.memory_stats(device)
            bytes_active = memory_stats.get('active_bytes.all.current', 0)
            bytes_reserved = memory_stats.get('reserved_bytes.all.current', 0)
            bytes_free_cuda, _ = torch.cuda.mem_get_info(device)
            bytes_inactive_reserved = bytes_reserved - bytes_active
            bytes_total_available = bytes_free_cuda + bytes_inactive_reserved
            return bytes_total_available / (1024 ** 3)
        except Exception as e:
            print("[Warning] Failed to get CUDA memory info:", e)
            return 0

    return 0


def move_model_to_device_with_memory_preservation(model, target_device, preserved_memory_gb=0):
    print(f'Moving {model.__class__.__name__} to {target_device} with preserved memory: {preserved_memory_gb} GB')

    for m in model.modules():
        if get_cuda_free_memory_gb(target_device) <= preserved_memory_gb:
            return

        if hasattr(m, 'weight'):
            m.to(device=target_device)

    model.to(device=target_device)
    return


def offload_model_from_device_for_memory_preservation(model, target_device, preserved_memory_gb=0):
    print(f'Offloading {model.__class__.__name__} from {target_device} to preserve memory: {preserved_memory_gb} GB')

    for m in model.modules():
        if get_cuda_free_memory_gb(target_device) >= preserved_memory_gb:
            return

        if hasattr(m, 'weight'):
            m.to(device=cpu)

    model.to(device=cpu)
    return


def unload_complete_models(*args):
    for m in gpu_complete_modules + list(args):
        m.to(device=cpu)
        print(f'Unloaded {m.__class__.__name__} as complete.')

    gpu_complete_modules.clear()
    return


def load_model_as_complete(model, target_device, unload=True):
    if unload:
        unload_complete_models()

    model.to(device=target_device)
    print(f'Loaded {model.__class__.__name__} to {target_device} as complete.')

    gpu_complete_modules.append(model)
    return

コピペしたら保存して閉じます。

本家FramePackを起動する

もう一度「Anaconda Prompt」を立ち上げて以下のコマンドを一行づつ実行していきます。

conda activate test_env

cd framepack
python -m venv venv
venv\Scripts\activate.bat

python -m pip install torch==2.7.0 torchvision==0.22.0 torchaudio==2.7.0 --index-url https://download.pytorch.org/whl/xpu
python -m pip install intel-extension-for-pytorch==2.7.10+xpu --extra-index-url https://pytorch-extension.intel.com/release-whl/stable/xpu/us/

pip install -r requirements.txt
python demo_gradio.py --inbrowser

最初はモデルダウンロードがありますが、40GBもあるので我慢して待ちましょう。

ダウンロードが終わると以下の画面がひらいて「FramePack」が起動します。
せっかく起動したのですが、必要なのは「hf_download」のモデルデータなので、そのまま「Anaconda Prompt」の画面で「Ctrl + C」で「FramePack」を停止します。

そうしたらそのまま

python endframe_ichi.py --inbrowser

を実行して「FramePack-eichi」を起動します。

終了した後、再度起動する場合は「Anaconda Prompt」を起動して

cd framepack
venv\Scripts\activate

python .\endframe_ichi.py --inbrowser

です。

「FramePack-eichi」の使い方はyoutubeで検索すると出てくると思うので、そちらを参考にしてください。
導入方法がUbuntu編とあまり変わり映えしなくて申し訳ないです。
といっても本当にあんまり変わらないので仕方ありません。

今回使ったB580です。

Amazon | SPARKLE Intel Arc B580 グラフィックカードOC版トリプルファン「TITAN」シリーズ [ B580 TITAN OC 12GB ] | スパークル(Sparkle) | グラフィックボード通販

SPARKLE Intel Arc B580 グラフィックカードOC版トリプルファン「TITAN」シリーズがグラフィックボードストアでいつでもお買い得。当日お急ぎ便対象商品は、当日お届け可能です。アマゾン配送商品は、通常配送無料（一部除...

Challenger安くなってますね。

Amazon | ASRock Intel Arc B580 Challenger PCIe 5.0対応 2.8GHz 12GB OC GDDR6搭載ビデオカード国内正規代理店品 B580 CL 12GO | ASRock | グラフィックボード通販

ASRock Intel Arc B580 Challenger PCIe 5.0対応 2.8GHz 12GB OC GDDR6搭載ビデオカード国内正規代理店品 B580 CL 12GOがグラフィックボードストアでいつでもお買い得。当日...

今回は以上です。