diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -1,3 +1,99 @@
+from diffusers_helper.hf_login import login
+
+import os
+import threading
+import time
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+import json
+
+os.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))
+
+# 日英両言語の翻訳辞書を追加
+translations = {
+ "en": {
+ "title": "FramePack - Image to Video Generation",
+ "upload_image": "Upload Image",
+ "prompt": "Prompt",
+ "quick_prompts": "Quick Prompts",
+ "start_generation": "Generate",
+ "stop_generation": "Stop",
+ "use_teacache": "Use TeaCache",
+ "teacache_info": "Faster speed, but may result in slightly worse finger and hand generation.",
+ "negative_prompt": "Negative Prompt",
+ "seed": "Seed",
+ "video_length": "Video Length (max 5 seconds)",
+ "latent_window": "Latent Window Size",
+ "steps": "Inference Steps",
+ "steps_info": "Changing this value is not recommended.",
+ "cfg_scale": "CFG Scale",
+ "distilled_cfg": "Distilled CFG Scale",
+ "distilled_cfg_info": "Changing this value is not recommended.",
+ "cfg_rescale": "CFG Rescale",
+ "gpu_memory": "GPU Memory Preservation (GB) (larger means slower)",
+ "gpu_memory_info": "Set this to a larger value if you encounter OOM errors. Larger values cause slower speed.",
+ "next_latents": "Next Latents",
+ "generated_video": "Generated Video",
+ "sampling_note": "Note: Due to reversed sampling, ending actions will be generated before starting actions. If the starting action is not in the video, please wait, it will be generated later.",
+ "error_message": "Error",
+ "processing_error": "Processing error",
+ "network_error": "Network connection is unstable, model download timed out. Please try again later.",
+ "memory_error": "GPU memory insufficient, please try increasing GPU memory preservation value or reduce video length.",
+ "model_error": "Failed to load model, possibly due to network issues or high server load. Please try again later.",
+ "partial_video": "Processing error, but partial video has been generated",
+ "processing_interrupt": "Processing was interrupted, but partial video has been generated"
+ },
+ "ja": {
+ "title": "FramePack - 画像から動画生成",
+ "upload_image": "画像をアップロード",
+ "prompt": "プロンプト",
+ "quick_prompts": "クイックプロンプト一覧",
+ "start_generation": "生成開始",
+ "stop_generation": "停止",
+ "use_teacache": "TeaCacheを使用",
+ "teacache_info": "処理速度が速くなりますが、指や手の生成品質が若干低下する可能性があります。",
+ "negative_prompt": "ネガティブプロンプト",
+ "seed": "シード値",
+ "video_length": "動画の長さ（最大5秒）",
+ "latent_window": "潜在窓サイズ",
+ "steps": "推論ステップ数",
+ "steps_info": "この値の変更は推奨されません。",
+ "cfg_scale": "CFGスケール",
+ "distilled_cfg": "蒸留CFGスケール",
+ "distilled_cfg_info": "この値の変更は推奨されません。",
+ "cfg_rescale": "CFGリスケール",
+ "gpu_memory": "GPU推論保存メモリ(GB)（値が大きいほど処理が遅くなります）",
+ "gpu_memory_info": "OOMエラーが発生した場合は、この値を大きくしてください。値が大きいほど処理が遅くなります。",
+ "next_latents": "次の潜在変数",
+ "generated_video": "生成された動画",
+ "sampling_note": "注意：逆順サンプリングのため、終了動作が開始動作より先に生成されます。開始動作が動画に表示されていない場合は、しばらくお待ちください。後で生成されます。",
+ "error_message": "エラーメッセージ",
+ "processing_error": "処理中にエラーが発生しました",
+ "network_error": "ネットワーク接続が不安定です。モデルのダウンロードがタイムアウトしました。後ほど再試行してください。",
+ "memory_error": "GPUメモリが不足しています。GPU推論保存メモリの値を大きくするか、動画の長さを短くしてください。",
+ "model_error": "モデルの読み込みに失敗しました。ネットワークの問題やサーバー負荷が高い可能性があります。後ほど再試行してください。",
+ "partial_video": "処理中にエラーが発生しましたが、部分的な動画は生成されています",
+ "processing_interrupt": "処理が中断されましたが、部分的な動画は生成されています"
+ }
+}
+
+# 言語切り替え機能
+def get_translation(key, lang="en"):
+ if lang in translations and key in translations[lang]:
+ return translations[lang][key]
+ # デフォルトで英語を返す
+ return translations["en"].get(key, key)
+
+# デフォルト言語設定
+current_language = "en"
+
+# 言語切り替え関数
+def switch_language():
+ global current_language
+ current_language = "ja" if current_language == "en" else "en"
+ return current_language
+
import gradio as gr
import torch
import traceback
@@ -6,114 +102,199 @@ import safetensors.torch as sf
import numpy as np
import math
-# 環境に応じた GPU 利用設定
+# Hugging Face Space環境内かどうか確認
IN_HF_SPACE = os.environ.get('SPACE_ID') is not None
+
+# GPU利用可能性を追跡する変数を追加
GPU_AVAILABLE = False
GPU_INITIALIZED = False
last_update_time = time.time()
-# Spaces 環境の場合、spaces モジュールをインポートして GPU 状態をチェック
+# Hugging Face Space内の場合、spacesモジュールをインポート
if IN_HF_SPACE:
try:
import spaces
- GPU_AVAILABLE = torch.cuda.is_available()
- if GPU_AVAILABLE:
- device_name = torch.cuda.get_device_name(0)
- total_mem = torch.cuda.get_device_properties(0).total_memory / 1e9
- print(f"GPU 利用可能: {device_name}, メモリ: {total_mem:.2f} GB")
- # 簡易テスト
- t = torch.zeros(1, device='cuda') + 1
- del t
- else:
- print("警告: CUDA は利用可能だが GPU が見つかりません")
+ print("Hugging Face Space環境内で実行中、spacesモジュールをインポートしました")
+
+ # GPU利用可能性をチェック
+ try:
+ GPU_AVAILABLE = torch.cuda.is_available()
+ print(f"GPU利用可能: {GPU_AVAILABLE}")
+ if GPU_AVAILABLE:
+ print(f"GPUデバイス名: {torch.cuda.get_device_name(0)}")
+ print(f"GPUメモリ: {torch.cuda.get_device_properties(0).total_memory / 1e9} GB")
+
+ # 小規模なGPU操作を試行し、GPUが実際に使用可能か確認
+ test_tensor = torch.zeros(1, device='cuda')
+ test_tensor = test_tensor + 1
+ del test_tensor
+ print("GPUテスト操作に成功しました")
+ else:
+ print("警告: CUDAが利用可能と報告されていますが、GPUデバイスが検出されませんでした")
+ except Exception as e:
+ GPU_AVAILABLE = False
+ print(f"GPU確認中にエラーが発生しました: {e}")
+ print("CPUモードで実行します")
except ImportError:
- print("spaces モジュールがインポートできませんでした")
+ print("spacesモジュールのインポートに失敗しました。Hugging Face Space環境外かもしれません")
GPU_AVAILABLE = torch.cuda.is_available()
-else:
- GPU_AVAILABLE = torch.cuda.is_available()
-# 出力用フォルダを作成
+from PIL import Image
+from diffusers import AutoencoderKLHunyuanVideo
+from transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer
+from diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
+from diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp
+from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
+from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
+from diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete, IN_HF_SPACE as MEMORY_IN_HF_SPACE
+from diffusers_helper.thread_utils import AsyncStream, async_run
+from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html
+from transformers import SiglipImageProcessor, SiglipVisionModel
+from diffusers_helper.clip_vision import hf_clip_vision_encode
+from diffusers_helper.bucket_tools import find_nearest_bucket
+
outputs_folder = './outputs/'
os.makedirs(outputs_folder, exist_ok=True)
-# モデル管理用グローバル変数
-models = {}
-cpu_fallback_mode = not GPU_AVAILABLE
+# Spaces環境では、すべてのCUDA操作を遅延させる
+if not IN_HF_SPACE:
+ # 非Spaces環境でのみCUDAメモリを取得
+ try:
+ if torch.cuda.is_available():
+ free_mem_gb = get_cuda_free_memory_gb(gpu)
+ print(f'空きVRAM {free_mem_gb} GB')
+ else:
+ free_mem_gb = 6.0 # デフォルト値
+ print("CUDAが利用できません。デフォルトのメモリ設定を使用します")
+ except Exception as e:
+ free_mem_gb = 6.0 # デフォルト値
+ print(f"CUDAメモリ取得中にエ���ーが発生しました: {e}、デフォルトのメモリ設定を使用します")
+
+ high_vram = free_mem_gb > 60
+ print(f'高VRAM モード: {high_vram}')
+else:
+ # Spaces環境ではデフォルト値を使用
+ print("Spaces環境でデフォルトのメモリ設定を使用します")
+ try:
+ if GPU_AVAILABLE:
+ free_mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9 * 0.9 # GPUメモリの90%を使用
+ high_vram = free_mem_gb > 10 # より保守的な条件
+ else:
+ free_mem_gb = 6.0 # デフォルト値
+ high_vram = False
+ except Exception as e:
+ print(f"GPUメモリ取得中にエラーが発生しました: {e}")
+ free_mem_gb = 6.0 # デフォルト値
+ high_vram = False
+
+ print(f'GPUメモリ: {free_mem_gb:.2f} GB, 高VRAMモード: {high_vram}')
-# モデルをロードする関数
+# modelsグローバル変数でモデル参照を保存
+models = {}
+cpu_fallback_mode = not GPU_AVAILABLE # GPUが利用できない場合、CPU代替モードを使用
+# モデルロード関数を使用
def load_models():
- """
- モデルをロードし、グローバル変数に保存します。
- 初回のみ実行され、以降はスキップされます。
- """
global models, cpu_fallback_mode, GPU_INITIALIZED
+
if GPU_INITIALIZED:
- print("モデルは既にロード済みです")
+ print("モデルはすでに読み込まれています。重複読み込みをスキップします")
return models
- print("モデルのロードを開始します...")
+
+ print("モデルの読み込みを開始しています...")
+
try:
- # デバイスとデータ型設定
+ # GPU利用可能性に基づいてデバイスを設定
device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
+ model_device = 'cpu' # 初期はCPUに読み込み
+
+ # メモリ節約のために精度を下げる
dtype = torch.float16 if GPU_AVAILABLE else torch.float32
transformer_dtype = torch.bfloat16 if GPU_AVAILABLE else torch.float32
+
+ print(f"使用デバイス: {device}, モデル精度: {dtype}, Transformer精度: {transformer_dtype}")
+
+ # モデルを読み込み
+ try:
+ text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to(model_device)
+ text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to(model_device)
+ tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
+ tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to(model_device)
+
+ feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
+ image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to(model_device)
+
+ transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('lllyasviel/FramePackI2V_HY', torch_dtype=transformer_dtype).to(model_device)
+
+ print("すべてのモデルの読み込みに成功しました")
+ except Exception as e:
+ print(f"モデル読み込み中にエラーが発生しました: {e}")
+ print("精度を下げて再試行します...")
+
+ # 精度を下げて再試行
+ dtype = torch.float32
+ transformer_dtype = torch.float32
+ cpu_fallback_mode = True
+
+ text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to('cpu')
+ text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to('cpu')
+ tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
+ tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to('cpu')
+
+ feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
+ image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to('cpu')
+
+ transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('tori29umai/FramePackI2V_HY_rotate_landscape', torch_dtype=transformer_dtype).to('cpu')
+
+ print("CPUモードですべてのモデルの読み込みに成功しました")
+
+ vae.eval()
+ text_encoder.eval()
+ text_encoder_2.eval()
+ image_encoder.eval()
+ transformer.eval()
+
+ if not high_vram or cpu_fallback_mode:
+ vae.enable_slicing()
+ vae.enable_tiling()
- # モデルを順次ロード
- from transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer
- from diffusers import AutoencoderKLHunyuanVideo
- from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
- from diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
- from diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, generate_timestamp
- from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
- from diffusers_helper.clip_vision import hf_clip_vision_encode
- from diffusers_helper.memory import get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, unload_complete_models, load_model_as_complete, DynamicSwapInstaller
- from diffusers_helper.thread_utils import AsyncStream, async_run
-
- # テキストエンコーダー
- text_encoder = LlamaModel.from_pretrained(
- "hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype
- ).to('cpu')
- text_encoder_2 = CLIPTextModel.from_pretrained(
- "hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype
- ).to('cpu')
- tokenizer = LlamaTokenizerFast.from_pretrained(
- "hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer'
- )
- tokenizer_2 = CLIPTokenizer.from_pretrained(
- "hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2'
- )
-
- # VAE
- vae = AutoencoderKLHunyuanVideo.from_pretrained(
- "hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype
- ).to('cpu')
-
- # 画像エンコーダー
- from transformers import SiglipImageProcessor, SiglipVisionModel
- feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
- image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to('cpu')
-
- # トランスフォーマーモデル
- transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
- 'tori29umai/FramePackI2V_HY_rotate_landscape', torch_dtype=transformer_dtype
- ).to('cpu')
-
- # 評価モードに設定
- vae.eval(); text_encoder.eval(); text_encoder_2.eval(); image_encoder.eval(); transformer.eval()
-
- # メモリ最適化
- vae.enable_slicing(); vae.enable_tiling()
transformer.high_quality_fp32_output_for_inference = True
-
- # デバイス移行
- if GPU_AVAILABLE and not cpu_fallback_mode:
+ print('transformer.high_quality_fp32_output_for_inference = True')
+
+ # モデル精度を設定
+ if not cpu_fallback_mode:
+ transformer.to(dtype=transformer_dtype)
+ vae.to(dtype=dtype)
+ image_encoder.to(dtype=dtype)
+ text_encoder.to(dtype=dtype)
+ text_encoder_2.to(dtype=dtype)
+
+ vae.requires_grad_(False)
+ text_encoder.requires_grad_(False)
+ text_encoder_2.requires_grad_(False)
+ image_encoder.requires_grad_(False)
+ transformer.requires_grad_(False)
+
+ if torch.cuda.is_available() and not cpu_fallback_mode:
try:
- DynamicSwapInstaller.install_model(transformer, device=device)
- DynamicSwapInstaller.install_model(text_encoder, device=device)
- except Exception:
- # GPU への移行に失敗した場合は CPU モードにフォールバック
+ if not high_vram:
+ # DynamicSwapInstallerはhuggingfaceのenable_sequential_offloadと同じですが3倍高速です
+ DynamicSwapInstaller.install_model(transformer, device=device)
+ DynamicSwapInstaller.install_model(text_encoder, device=device)
+ else:
+ text_encoder.to(device)
+ text_encoder_2.to(device)
+ image_encoder.to(device)
+ vae.to(device)
+ transformer.to(device)
+ print(f"モデルを{device}デバイスに移動することに成功しました")
+ except Exception as e:
+ print(f"モデルを{device}に移動中にエラーが発生しました: {e}")
+ print("CPUモードにフォールバックします")
cpu_fallback_mode = True
-
+
# グローバル変数に保存
models = {
'text_encoder': text_encoder,
@@ -125,420 +306,1352 @@ def load_models():
'image_encoder': image_encoder,
'transformer': transformer
}
+
GPU_INITIALIZED = True
- print(f"モデルロード完了。モード: {'GPU' if not cpu_fallback_mode else 'CPU'}")
+ print(f"モデルの読み込みが完了しました。実行モード: {'CPU' if cpu_fallback_mode else 'GPU'}")
return models
-
except Exception as e:
- # エラー発生時の処理
- print(f"モデルロード中にエラー発生: {e}")
+ print(f"モデル読み込みプロセスでエラーが発生しました: {e}")
traceback.print_exc()
- # ログをファイルに出力
+
+ # より詳細なエラー情報を記録
+ error_info = {
+ "error": str(e),
+ "traceback": traceback.format_exc(),
+ "cuda_available": torch.cuda.is_available(),
+ "device": "cpu" if cpu_fallback_mode else "cuda",
+ }
+
+ # トラブルシューティングのためにエラー情報をファイルに保存
try:
with open(os.path.join(outputs_folder, "error_log.txt"), "w") as f:
- f.write(traceback.format_exc())
+ f.write(str(error_info))
except:
pass
+
+ # アプリが引き続き実行を試みることができるよう空の辞書を返す
cpu_fallback_mode = True
return {}
+# Hugging Face Spaces GPU装飾子を使用
+if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE:
+ try:
+ @spaces.GPU
+ def initialize_models():
+ """@spaces.GPU装飾子内でモデルを初期化"""
+ global GPU_INITIALIZED
+ try:
+ result = load_models()
+ GPU_INITIALIZED = True
+ return result
+ except Exception as e:
+ print(f"spaces.GPUを使用したモデル初期化中にエラーが発生しました: {e}")
+ traceback.print_exc()
+ global cpu_fallback_mode
+ cpu_fallback_mode = True
+ # 装飾子を使わずに再試行
+ return load_models()
+ except Exception as e:
+ print(f"spaces.GPU装飾子の作成中にエラーが発生しました: {e}")
+ # 装飾子がエラーの場合、非装飾子版を直接使用
+ def initialize_models():
+ return load_models()
+
+
+# 以下の関数内部でモデルの取得を遅延させる
def get_models():
- """
- モデルを返す。未ロードならロードを実行。
- """
- global models
+ """モデルを取得し、まだ読み込まれていない場合は読み込む"""
+ global models, GPU_INITIALIZED
+
+ # 並行読み込みを防ぐためのモデル読み込みロックを追加
+ model_loading_key = "__model_loading__"
+
if not models:
- models = load_models()
+ # モデルが読み込み中かチェック
+ if model_loading_key in globals():
+ print("モデルは現在読み込み中です。お待ちください...")
+ # モデル読み込み完了を待機
+ import time
+ start_wait = time.time()
+ while not models and model_loading_key in globals():
+ time.sleep(0.5)
+ # 60秒以上待機したら読み込み失敗と判断
+ if time.time() - start_wait > 60:
+ print("モデル読み込み待機がタイムアウトしました")
+ break
+
+ if models:
+ return models
+
+ try:
+ # 読み込みフラグを設定
+ globals()[model_loading_key] = True
+
+ if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE and not cpu_fallback_mode:
+ try:
+ print("@spaces.GPU装飾子を使用してモデルを読み込みます")
+ models = initialize_models()
+ except Exception as e:
+ print(f"GPU装飾子を使用したモデル読み込みに失敗しました: {e}")
+ print("直接モデルを読み込みます")
+ models = load_models()
+ else:
+ print("モデルを直接読み込みます")
+ models = load_models()
+ except Exception as e:
+ print(f"モデル読み込み中に予期しないエラーが発生しました: {e}")
+ traceback.print_exc()
+ # 空の辞書を確保
+ models = {}
+ finally:
+ # 成功か失敗にかかわらず、読み込みフラグを削除
+ if model_loading_key in globals():
+ del globals()[model_loading_key]
+
return models
-# 非同期ストリーム
-stream = None
+
+stream = AsyncStream()
+
@torch.no_grad()
-def worker(input_image, prompt, n_prompt, seed, total_second_length,
- latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
- """
- 実際の動画生成処理を行うワーカー関数。
- 入力画像とプロンプトから逐次進捗を返却。
- """
- global last_update_time, stream
+def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
+ global last_update_time
last_update_time = time.time()
+
+ # 動画の長さを5秒以下に制限
total_second_length = min(total_second_length, 5.0)
-
- # モデル取得
- models_data = get_models()
- if not models_data:
- stream.output_queue.push(('error', 'モデルロード失敗'))
+
+ # モデルを取得
+ try:
+ models = get_models()
+ if not models:
+ error_msg = "モデルの読み込みに失敗しました。詳細情報はログを確認してください"
+ print(error_msg)
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ text_encoder = models['text_encoder']
+ text_encoder_2 = models['text_encoder_2']
+ tokenizer = models['tokenizer']
+ tokenizer_2 = models['tokenizer_2']
+ vae = models['vae']
+ feature_extractor = models['feature_extractor']
+ image_encoder = models['image_encoder']
+ transformer = models['transformer']
+ except Exception as e:
+ error_msg = f"モデル取得中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ stream.output_queue.push(('error', error_msg))
stream.output_queue.push(('end', None))
return
-
- text_encoder = models_data['text_encoder']
- text_encoder_2 = models_data['text_encoder_2']
- tokenizer = models_data['tokenizer']
- tokenizer_2 = models_data['tokenizer_2']
- vae = models_data['vae']
- feature_extractor = models_data['feature_extractor']
- image_encoder = models_data['image_encoder']
- transformer = models_data['transformer']
-
- # デバイス決定
+
+ # デバイスを決定
device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
+ print(f"推論に使用するデバイス: {device}")
+
+ # CPUモードに合わせてパラメータを調整
if cpu_fallback_mode:
+ print("CPUモードではより軽量なパラメータを使用します")
+ # CPU処理を高速化するために処理サイズを小さくする
latent_window_size = min(latent_window_size, 5)
- steps = min(steps, 15)
- total_second_length = min(total_second_length, 2.0)
-
- # フレーム数計算
- total_latent_sections = max(int(round((total_second_length * 30) / (latent_window_size * 4))), 1)
- job_id = str(int(time.time() * 1000))
- history_latents = None
+ steps = min(steps, 15) # ステップ数を減らす
+ total_second_length = min(total_second_length, 2.0) # CPUモードでは動画の長さをさらに制限
+
+ total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)
+ total_latent_sections = int(max(round(total_latent_sections), 1))
+
+ job_id = generate_timestamp()
+ last_output_filename = None
history_pixels = None
+ history_latents = None
total_generated_latent_frames = 0
- # 進捗開始
- stream.output_queue.push(('progress', (None, '', '開始...
')))
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, '開始中 ...'))))
- # ここからサンプリングとエンコード処理を実装
- # （省略せず全て実装）
- # ...
+ try:
+ # GPUをクリーン
+ if not high_vram and not cpu_fallback_mode:
+ try:
+ unload_complete_models(
+ text_encoder, text_encoder_2, image_encoder, vae, transformer
+ )
+ except Exception as e:
+ print(f"モデルのアンロード中にエラーが発生しました: {e}")
+ # 処理を中断せずに続行
- # 終了シグナル送信
- stream.output_queue.push(('end', None))
- return
+ # テキストエンコーディング
+ last_update_time = time.time()
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'テキストエンコーディング中 ...'))))
-# GPU 装飾器付き処理関数（Spaces用）
-if IN_HF_SPACE:
- @spaces.GPU
-def process_with_gpu(input_image, prompt, n_prompt, seed,
- total_second_length, latent_window_size, steps,
- cfg, gs, rs, gpu_memory_preservation, use_teacache):
- """
- Hugging Face Spaces GPU上でのプロセス関数。
- """
- global stream
- stream = AsyncStream()
- threading.Thread(
- target=async_run,
- args=(worker, input_image, prompt, n_prompt, seed,
- total_second_length, latent_window_size, steps,
- cfg, gs, rs, gpu_memory_preservation, use_teacache)
- ).start()
-
- output_filename = None
- prev_output = None
- error_msg = None
-
- while True:
- flag, data = stream.output_queue.next()
- if flag == 'file':
- output_filename = data
- prev_output = data
- yield data, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive(True))
- elif flag == 'progress':
- preview, desc, html = data
- yield gr.update(), preview, desc, html, gr.update(interactive=False), gr.update(interactive(True))
- elif flag == 'error':
- error_msg = data
- elif flag == 'end':
- if error_msg:
- yield prev_output, gr.update(visible=False), gr.update(), f'{error_msg}
', gr.update(interactive(True)), gr.update(interactive(False))
- else:
- yield prev_output, gr.update(visible=False), gr.update(), '', gr.update(interactive(True)), gr.update(interactive(False))
- break
+ try:
+ if not high_vram and not cpu_fallback_mode:
+ fake_diffusers_current_device(text_encoder, device)
+ load_model_as_complete(text_encoder_2, target_device=device)
-def process(*args):
- """
- GPU装飾器なしの通常処理関数。
- """
- return process_with_gpu(*args)
+ llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+ if cfg == 1:
+ llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
+ else:
+ llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+
+ llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
+ llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
+ except Exception as e:
+ error_msg = f"テキストエンコーディング中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ # 入力画像の処理
+ last_update_time = time.time()
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, '画像処理中 ...'))))
-def end_process():
- """
- 生成処理を中断する関数。
- """
- global stream
- if stream:
- stream.input_queue.push('end')
- return None
+ try:
+ H, W, C = input_image.shape
+ height, width = find_nearest_bucket(H, W, resolution=640)
+
+ # CPUモードの場合、処理サイズを小さくする
+ if cpu_fallback_mode:
+ height = min(height, 320)
+ width = min(width, 320)
+
+ input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)
+
+ Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))
+
+ input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1
+ input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]
+ except Exception as e:
+ error_msg = f"画像処理中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ # VAEエンコーディング
+ last_update_time = time.time()
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAEエンコーディング中 ...'))))
-# ---- Gradio UI 定義 ----
-# カスタムCSSを定義（省略せず記載）
-def make_custom_css():
- """カスタムCSSを返します。レスポンシブ対応とエラー表示用スタイルを含む"""
- combined_css = """
- /* CSS内容をここに全て記載 */
- """
- return combined_css
+ try:
+ if not high_vram and not cpu_fallback_mode:
+ load_model_as_complete(vae, target_device=device)
+
+ start_latent = vae_encode(input_image_pt, vae)
+ except Exception as e:
+ error_msg = f"VAEエンコーディング中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ # CLIP Vision
+ last_update_time = time.time()
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Visionエンコーディング中 ...'))))
-css = make_custom_css()
-block = gr.Blocks(css=css).queue()
-with block:
- # タイトル
- gr.Markdown("# FramePack - 画像から動画生成")
+ try:
+ if not high_vram and not cpu_fallback_mode:
+ load_model_as_complete(image_encoder, target_device=device)
+
+ image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
+ image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
+ except Exception as e:
+ error_msg = f"CLIP Visionエンコーディング中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ # データ型
+ try:
+ llama_vec = llama_vec.to(transformer.dtype)
+ llama_vec_n = llama_vec_n.to(transformer.dtype)
+ clip_l_pooler = clip_l_pooler.to(transformer.dtype)
+ clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
+ image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
+ except Exception as e:
+ error_msg = f"データ型変換中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ # サンプリング
+ last_update_time = time.time()
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'サンプリング開始 ...'))))
+
+ rnd = torch.Generator("cpu").manual_seed(seed)
+ num_frames = latent_window_size * 4 - 3
- with gr.Row():
- with gr.Column():
- input_image = gr.Image(
- source='upload',
- type='numpy',
- label='画像をアップロード',
- height=320
- )
- prompt = gr.Textbox(
- label='プロンプト',
- placeholder='The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view'
- )
- quick = gr.Dataset(
- samples=[['The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view']],
- label='クイックプロンプト',
- samples_per_page=10,
- components=[prompt]
- )
- quick.click(lambda x: x[0], inputs=[quick], outputs=prompt)
-
- with gr.Row():
- start_btn = gr.Button('生成開始', variant='primary')
- stop_btn = gr.Button('生成停止', interactive=False)
-
- seed = gr.Number(label='シード値', value=31337, precision=0)
- length = gr.Slider(label='動画の長さ (最大5秒)', minimum=1, maximum=5, value=5, step=0.1)
- steps_slider = gr.Slider(label='推論ステップ数', minimum=1, maximum=100, value=25, step=1)
- teacache = gr.Checkbox(label='TeaCacheを使用', value=True,
- info='高速化しますが、手指の生成品質が若干低下する可能性があります。')
-
- with gr.Column():
- preview = gr.Image(label='プレビュー', visible=False, height=200)
- result = gr.Video(label='生成された動画', autoplay=True, loop=True, height=512)
- progress_desc = gr.Markdown('')
- progress_bar = gr.HTML('')
- error_html = gr.HTML('', visible=True)
-
- start_btn.click(fn=process, inputs=[input_image, prompt, None, seed, length, None, steps_slider, None, None, None, None, teacache],
- outputs=[result, preview, progress_desc, progress_bar, start_btn, stop_btn])
- stop_btn.click(fn=end_process)
-
- # アプリ起動
- device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
- print(f"使用デバイス: {device} を推論に使います")
+ try:
+ history_latents = torch.zeros(size=(1, 16, 1 + 2 + 16, height // 8, width // 8), dtype=torch.float32).cpu()
+ history_pixels = None
+ total_generated_latent_frames = 0
+ except Exception as e:
+ error_msg = f"履歴状態の初期化中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ latent_paddings = reversed(range(total_latent_sections))
+
+ if total_latent_sections > 4:
+ # 理論的にはlatent_paddingsは上記のシーケンスに従うべきですが、
+ # total_latent_sections > 4の場合、展開するよりもいくつかの項目を複製する方が
+ # 良い結果になるようです
+ # 比較するために、latent_paddings = list(reversed(range(total_latent_sections)))を
+ # 使用して下記のトリックを削除することもできます
+ latent_paddings = [3] + [2] * (total_latent_sections - 3) + [1, 0]
+
+ for latent_padding in latent_paddings:
+ last_update_time = time.time()
+ is_last_section = latent_padding == 0
+ latent_padding_size = latent_padding * latent_window_size
+
+ if stream.input_queue.top() == 'end':
+ # 終了時に現在の動画を保存することを確認
+ if history_pixels is not None and total_generated_latent_frames > 0:
+ try:
+ output_filename = os.path.join(outputs_folder, f'{job_id}_final_{total_generated_latent_frames}.mp4')
+ save_bcthw_as_mp4(history_pixels, output_filename, fps=30)
+ stream.output_queue.push(('file', output_filename))
+ except Exception as e:
+ print(f"最終動画保存中にエラーが発生しました: {e}")
+
+ stream.output_queue.push(('end', None))
+ return
+
+ print(f'latent_padding_size = {latent_padding_size}, is_last_section = {is_last_section}')
- # 評価モードに設定
- vae.eval(); text_encoder.eval(); text_encoder_2.eval(); image_encoder.eval(); transformer.eval()
+ try:
+ indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)
+ clean_latent_indices_pre, blank_indices, latent_indices, clean_latent_indices_post, clean_latent_2x_indices, clean_latent_4x_indices = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
+ clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)
+
+ clean_latents_pre = start_latent.to(history_latents)
+ clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, :1 + 2 + 16, :, :].split([1, 2, 16], dim=2)
+ clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)
+ except Exception as e:
+ error_msg = f"サンプリングデータ準備中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+ # 完全に終了せずに次のイテレーションを試みる
+ if last_output_filename:
+ stream.output_queue.push(('file', last_output_filename))
+ continue
+
+ if not high_vram and not cpu_fallback_mode:
+ try:
+ unload_complete_models()
+ move_model_to_device_with_memory_preservation(transformer, target_device=device, preserved_memory_gb=gpu_memory_preservation)
+ except Exception as e:
+ print(f"transformerをGPUに移動中にエラーが発生しました: {e}")
+ # パフォーマンスに影響する可能性はありますが、終了する必要はないので続行
+
+ if use_teacache and not cpu_fallback_mode:
+ try:
+ transformer.initialize_teacache(enable_teacache=True, num_steps=steps)
+ except Exception as e:
+ print(f"teacache初期化中にエラーが発生しました: {e}")
+ # teacacheを無効にして続行
+ transformer.initialize_teacache(enable_teacache=False)
+ else:
+ transformer.initialize_teacache(enable_teacache=False)
+
+ def callback(d):
+ global last_update_time
+ last_update_time = time.time()
+
+ try:
+ # まず停止信号があるかチェック
+ print(f"【デバッグ】コールバック関数: ステップ {d['i']}, 停止信号のチェック")
+ try:
+ queue_top = stream.input_queue.top()
+ print(f"【デバッグ】コールバック関数: キュー先頭信号 = {queue_top}")
+
+ if queue_top == 'end':
+ print("【デバッグ】コールバック関数: 停止信号を検出、中断準備中...")
+ try:
+ stream.output_queue.push(('end', None))
+ print("【デバッグ】コールバック関数: 出力キューにend信号を正常に送信")
+ except Exception as e:
+ print(f"【デバッグ】コールバック関数: 出力キューにend信号送信中にエラー: {e}")
+
+ print("【デバッグ】コールバック関数: KeyboardInterrupt例外を投げる準備")
+ raise KeyboardInterrupt('ユーザーによるタスク停止')
+ except Exception as e:
+ print(f"【デバッグ】コールバック関数: キュー先頭信号チェック中にエラー: {e}")
+
+ preview = d['denoised']
+ preview = vae_decode_fake(preview)
+
+ preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)
+ preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')
+
+ current_step = d['i'] + 1
+ percentage = int(100.0 * current_step / steps)
+ hint = f'サンプリング中 {current_step}/{steps}'
+ desc = f'総生成フレーム数: {int(max(0, total_generated_latent_frames * 4 - 3))}, 動画長: {max(0, (total_generated_latent_frames * 4 - 3) / 30) :.2f} 秒 (FPS-30). 動画を現在拡張中...'
+ stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
+ except KeyboardInterrupt as e:
+ # 中断例外をキャッチして再スローし、サンプリング関数に伝播されるようにする
+ print(f"【デバッグ】コールバック関数: KeyboardInterruptをキャッチ: {e}")
+ print("【デバッグ】コールバック関数: 中断例外を再スロー、サンプリング関数に伝播")
+ raise
+ except Exception as e:
+ print(f"【デバッグ】コールバック関数でエラー: {e}")
+ # サンプリングプロセスを中断しない
+ print(f"【デバッグ】コールバック関数: ステップ {d['i']} 完了")
+ return
- # メモリ最適化
- vae.enable_slicing(); vae.enable_tiling()
- transformer.high_quality_fp32_output_for_inference = True
+ try:
+ sampling_start_time = time.time()
+ print(f"サンプリング開始、デバイス: {device}, データ型: {transformer.dtype}, TeaCache使用: {use_teacache and not cpu_fallback_mode}")
+
+ try:
+ print("【デバッグ】sample_hunyuanサンプリングプロセス開始")
+ generated_latents = sample_hunyuan(
+ transformer=transformer,
+ sampler='unipc',
+ width=width,
+ height=height,
+ frames=num_frames,
+ real_guidance_scale=cfg,
+ distilled_guidance_scale=gs,
+ guidance_rescale=rs,
+ # shift=3.0,
+ num_inference_steps=steps,
+ generator=rnd,
+ prompt_embeds=llama_vec,
+ prompt_embeds_mask=llama_attention_mask,
+ prompt_poolers=clip_l_pooler,
+ negative_prompt_embeds=llama_vec_n,
+ negative_prompt_embeds_mask=llama_attention_mask_n,
+ negative_prompt_poolers=clip_l_pooler_n,
+ device=device,
+ dtype=transformer.dtype,
+ image_embeddings=image_encoder_last_hidden_state,
+ latent_indices=latent_indices,
+ clean_latents=clean_latents,
+ clean_latent_indices=clean_latent_indices,
+ clean_latents_2x=clean_latents_2x,
+ clean_latent_2x_indices=clean_latent_2x_indices,
+ clean_latents_4x=clean_latents_4x,
+ clean_latent_4x_indices=clean_latent_4x_indices,
+ callback=callback,
+ )
+
+ print(f"【デバッグ】サンプリング完了、所要時間: {time.time() - sampling_start_time:.2f}秒")
+ except KeyboardInterrupt as e:
+ # ユーザーによる中断
+ print(f"【デバッグ】KeyboardInterruptをキャッチ: {e}")
+ print("【デバッグ】ユーザーによるサンプリングプロセス中断、中断ロジック処理中")
+
+ # 既に生成された動画がある場合、最後に生成された動画を返す
+ if last_output_filename:
+ print(f"【デバッグ】部分的に生成された動画あり: {last_output_filename}、この動画を返します")
+ stream.output_queue.push(('file', last_output_filename))
+ error_msg = "ユーザーにより生成プロセス��中断されましたが、部分的な動画は生成されています"
+ else:
+ print("【デバッグ】部分的に生成された動画なし、中断メッセージを返します")
+ error_msg = "ユーザーにより生成プロセスが中断され、動画は生成されていません"
+
+ print(f"【デバッグ】エラーメッセージを送信: {error_msg}")
+ stream.output_queue.push(('error', error_msg))
+ print("【デバッグ】end信号を送信")
+ stream.output_queue.push(('end', None))
+ print("【デバッグ】中断処理完了、リターン")
+ return
+ except Exception as e:
+ print(f"サンプリングプロセス中にエラーが発生しました: {e}")
+ traceback.print_exc()
+
+ # 既に生成された動画がある場合、最後に生成された動画を返す
+ if last_output_filename:
+ stream.output_queue.push(('file', last_output_filename))
+
+ # エラーメッセージを作成
+ error_msg = f"サンプリングプロセス中にエラーが発生しましたが、部分的に生成された動画を返します: {e}"
+ stream.output_queue.push(('error', error_msg))
+ else:
+ # 生成された動画がない場合、エラーメッセージを返す
+ error_msg = f"サンプリングプロセス中にエラーが発生し、動画を生成できませんでした: {e}"
+ stream.output_queue.push(('error', error_msg))
+
+ stream.output_queue.push(('end', None))
+ return
- # デバイス移行
- if GPU_AVAILABLE and not cpu_fallback_mode:
try:
- DynamicSwapInstaller.install_model(transformer, device=device)
- DynamicSwapInstaller.install_model(text_encoder, device=device)
- except Exception:
- # GPU への移行に失敗した場合は CPU モードにフォールバック
- cpu_fallback_mode = True
+ if is_last_section:
+ generated_latents = torch.cat([start_latent.to(generated_latents), generated_latents], dim=2)
+
+ total_generated_latent_frames += int(generated_latents.shape[2])
+ history_latents = torch.cat([generated_latents.to(history_latents), history_latents], dim=2)
+ except Exception as e:
+ error_msg = f"生成された潜在変数の処理中にエラーが発生しました: {e}"
+ print(error_msg)
+ traceback.print_exc()
+
+ if last_output_filename:
+ stream.output_queue.push(('file', last_output_filename))
+ stream.output_queue.push(('error', error_msg))
+ stream.output_queue.push(('end', None))
+ return
+
+ if not high_vram and not cpu_fallback_mode:
+ try:
+ offload_model_from_device_for_memory_preservation(transformer, target_device=device, preserved_memory_gb=8)
+ load_model_as_complete(vae, target_device=device)
+ except Exception as e:
+ print(f"モデルメモリ管理中にエラーが発生しました: {e}")
+ # 続行
- # グローバル変数に保存
- models = {
- 'text_encoder': text_encoder,
- 'text_encoder_2': text_encoder_2,
- 'tokenizer': tokenizer,
- 'tokenizer_2': tokenizer_2,
- 'vae': vae,
- 'feature_extractor': feature_extractor,
- 'image_encoder': image_encoder,
- 'transformer': transformer
- }
- GPU_INITIALIZED = True
- print(f"モデルロード完了。モード: {'GPU' if not cpu_fallback_mode else 'CPU'}")
- return models
+ try:
+ real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :]
+ except Exception as e:
+ error_msg = f"履歴潜在変数の処理中にエラーが発生しました: {e}"
+ print(error_msg)
+
+ if last_output_filename:
+ stream.output_queue.push(('file', last_output_filename))
+ continue
+ try:
+ vae_start_time = time.time()
+ print(f"VAEデコード開始、潜在変数形状: {real_history_latents.shape}")
+
+ if history_pixels is None:
+ history_pixels = vae_decode(real_history_latents, vae).cpu()
+ else:
+ section_latent_frames = (latent_window_size * 2 + 1) if is_last_section else (latent_window_size * 2)
+ overlapped_frames = latent_window_size * 4 - 3
+
+ current_pixels = vae_decode(real_history_latents[:, :, :section_latent_frames], vae).cpu()
+ history_pixels = soft_append_bcthw(current_pixels, history_pixels, overlapped_frames)
+
+ print(f"VAEデコード完了、所要時間: {time.time() - vae_start_time:.2f}秒")
+
+ if not high_vram and not cpu_fallback_mode:
+ try:
+ unload_complete_models()
+ except Exception as e:
+ print(f"モデルのアンロード中にエラーが発生しました: {e}")
+
+ output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')
+
+ save_start_time = time.time()
+ save_bcthw_as_mp4(history_pixels, output_filename, fps=30)
+ print(f"動画保存完了、所要時間: {time.time() - save_start_time:.2f}秒")
+
+ print(f'デコード完了。現在の潜在変数形状 {real_history_latents.shape}; ピクセル形状 {history_pixels.shape}')
+
+ last_output_filename = output_filename
+ stream.output_queue.push(('file', output_filename))
+ except Exception as e:
+ print(f"動画のデコードまたは保存中にエラーが発生しました: {e}")
+ traceback.print_exc()
+
+ # 既に生成された動画がある場合、最後に生成された動画を返す
+ if last_output_filename:
+ stream.output_queue.push(('file', last_output_filename))
+
+ # エラー情報を記録
+ error_msg = f"動画のデコードまたは保存中にエラーが発生しました: {e}"
+ stream.output_queue.push(('error', error_msg))
+
+ # 次のイテレーションを試みる
+ continue
+
+ if is_last_section:
+ break
except Exception as e:
- # エラー発生時の処理
- print(f"モデルロード中にエラー発生: {e}")
+ print(f"【デバッグ】処理中にエラーが発生しました: {e}, タイプ: {type(e)}")
+ print(f"【デバッグ】エラー詳細:")
traceback.print_exc()
- # ログをファイルに出力
- try:
- with open(os.path.join(outputs_folder, "error_log.txt"), "w") as f:
- f.write(traceback.format_exc())
- except:
- pass
- cpu_fallback_mode = True
- return {}
+
+ # 中断型例外かチェック
+ if isinstance(e, KeyboardInterrupt):
+ print("【デバッグ】外部KeyboardInterrupt例外を検出")
+ if not high_vram and not cpu_fallback_mode:
+ try:
+ print("【デバッグ】リソース解放のためモデルをアンロード")
+ unload_complete_models(
+ text_encoder, text_encoder_2, image_encoder, vae, transformer
+ )
+ print("【デバッグ】モデルのアンロードに成功")
+ except Exception as unload_error:
+ print(f"【デバッグ】モデルのアンロード中にエラー: {unload_error}")
+ pass
+
+ # 既に生成された動画がある場合、最後に生成された動画を返す
+ if last_output_filename:
+ print(f"【デバッグ】外部例外処理: 生成済み部分動画を返す {last_output_filename}")
+ stream.output_queue.push(('file', last_output_filename))
+ else:
+ print("【デバッグ】外部例外処理: 生成済み動画が見つかりません")
+
+ # エラーメッセージを返す
+ error_msg = f"処理中にエラーが発生しました: {e}"
+ print(f"【デバッグ】外部例外処理: エラーメッセージを送信: {error_msg}")
+ stream.output_queue.push(('error', error_msg))
+
+ # 常にend信号を返すことを確認
+ print("【デバッグ】ワーカー関数終了、end信号を送信")
+ stream.output_queue.push(('end', None))
+ return
-def get_models():
- """
- モデルを返す。未ロードならロードを実行。
- """
- global models
- if not models:
- models = load_models()
- return models
-
-# 非同期ストリーム
-stream = None
-
-@torch.no_grad()
-def worker(input_image, prompt, n_prompt, seed, total_second_length,
- latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
- """
- 実際の動画生成処理を行うワーカー関数。
- 入力画像とプロンプトから逐次進捗を返却。
- """
- global last_update_time, stream
- last_update_time = time.time()
- total_second_length = min(total_second_length, 5.0)
- # モデル取得
- models_data = get_models()
- if not models_data:
- stream.output_queue.push(('error', 'モデルロード失敗'))
- stream.output_queue.push(('end', None))
- return
+# Hugging Face Spaces GPU装飾子を使用してプロセス関数を処理
+if IN_HF_SPACE and 'spaces' in globals():
+ @spaces.GPU
+ def process_with_gpu(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
+ global stream
+ assert input_image is not None, '入力画像がありません！'
- text_encoder = models_data['text_encoder']
- text_encoder_2 = models_data['text_encoder_2']
- tokenizer = models_data['tokenizer']
- tokenizer_2 = models_data['tokenizer_2']
- vae = models_data['vae']
- feature_extractor = models_data['feature_extractor']
- image_encoder = models_data['image_encoder']
- transformer = models_data['transformer']
+ # UI状態の初期化
+ yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
- # デバイス決定
- device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
- if cpu_fallback_mode:
- latent_window_size = min(latent_window_size, 5)
- steps = min(steps, 15)
- total_second_length = min(total_second_length, 2.0)
+ try:
+ stream = AsyncStream()
+
+ # ワーカーを非同期で起動
+ async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)
+
+ output_filename = None
+ prev_output_filename = None
+ error_message = None
+
+ # ワーカーの出力を継続的にチェック
+ while True:
+ try:
+ flag, data = stream.output_queue.next()
+
+ if flag == 'file':
+ output_filename = data
+ prev_output_filename = output_filename
+ # ファイル成功時にエラー表示をクリア
+ yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)
+
+ if flag == 'progress':
+ preview, desc, html = data
+ # 進捗更新時にエラーメッセージを変更せず、停止ボタンがインタラクティブであることを確認
+ yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
+
+ if flag == 'error':
+ error_message = data
+ print(f"エラーメッセージを受信: {error_message}")
+ # 即時表示せず、end信号を待機
+
+ if flag == 'end':
+ # 最後の動画ファイルがある場合、確実に返す
+ if output_filename is None and prev_output_filename is not None:
+ output_filename = prev_output_filename
+
+ # エラーメッセージがある場合、わかりやすいエラー表示を作成
+ if error_message:
+ error_html = create_error_html(error_message)
+ yield output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+ else:
+ # 成功時にエラー表示をしない
+ yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
+ break
+ except Exception as e:
+ print(f"出力処理中にエラーが発生しました: {e}")
+ # 長時間更新がないか確認
+ current_time = time.time()
+ if current_time - last_update_time > 60: # 60秒間更新がない場合、処理がフリーズした可能性
+ print(f"処理がフリーズした可能性があります。{current_time - last_update_time:.1f}秒間更新がありません")
+
+ # 部分的に生成された動画がある場合、それを返す
+ if prev_output_filename:
+ error_html = create_error_html("処理がタイムアウトしましたが、部分的な動画は生成されています", is_timeout=True)
+ yield prev_output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+ else:
+ error_html = create_error_html(f"処理がタイムアウトしました: {e}", is_timeout=True)
+ yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+ break
+
+ except Exception as e:
+ print(f"処理の開始中にエラーが発生しました: {e}")
+ traceback.print_exc()
+ error_msg = str(e)
+
+ error_html = create_error_html(error_msg)
+ yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+
+ process = process_with_gpu
+else:
+ def process(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
+ global stream
+ assert input_image is not None, '入力画像がありません！'
- # フレーム数計算
- total_latent_sections = max(int(round((total_second_length * 30) / (latent_window_size * 4))), 1)
- job_id = str(int(time.time() * 1000))
- history_latents = None
- history_pixels = None
- total_generated_latent_frames = 0
+ # UI状態の初期化
+ yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
- # 進捗開始
- stream.output_queue.push(('progress', (None, '', '開始...
')))
+ try:
+ stream = AsyncStream()
+
+ # ワーカーを非同期で起動
+ async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)
+
+ output_filename = None
+ prev_output_filename = None
+ error_message = None
+
+ # ワーカーの出力を継続的にチェック
+ while True:
+ try:
+ flag, data = stream.output_queue.next()
+
+ if flag == 'file':
+ output_filename = data
+ prev_output_filename = output_filename
+ # ファイル成功時にエラー表示をクリア
+ yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)
+
+ if flag == 'progress':
+ preview, desc, html = data
+ # 進捗更新時にエラーメッセージを変更せず、停止ボタンがインタラクティブであることを確認
+ yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
+
+ if flag == 'error':
+ error_message = data
+ print(f"エラーメッセージを受信: {error_message}")
+ # 即時表示せず、end信号を待機
+
+ if flag == 'end':
+ # 最後の動画ファイルがある場合、確実に返す
+ if output_filename is None and prev_output_filename is not None:
+ output_filename = prev_output_filename
+
+ # エラーメッセージがある場合、わかりやすいエラー表示を作成
+ if error_message:
+ error_html = create_error_html(error_message)
+ yield output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+ else:
+ # 成功時にエラー表示をしない
+ yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
+ break
+ except Exception as e:
+ print(f"出力処理中にエラーが発生しました: {e}")
+ # 長時間更新がないか確認
+ current_time = time.time()
+ if current_time - last_update_time > 60: # 60秒間更新がない場合、処理がフリーズした可能性
+ print(f"処理がフリーズした可能性があります。{current_time - last_update_time:.1f}秒間更新がありません")
+
+ # 部分的に生成された動画がある場合、それを返す
+ if prev_output_filename:
+ error_html = create_error_html("処理がタイムアウトしましたが、部分的な動画は生成されています", is_timeout=True)
+ yield prev_output_filename, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+ else:
+ error_html = create_error_html(f"処理がタイムアウトしました: {e}", is_timeout=True)
+ yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
+ break
+
+ except Exception as e:
+ print(f"処理の開始中にエラーが発生しました: {e}")
+ traceback.print_exc()
+ error_msg = str(e)
+
+ error_html = create_error_html(error_msg)
+ yield None, gr.update(visible=False), gr.update(), error_html, gr.update(interactive=True), gr.update(interactive=False)
- # 終了シグナル送信
- stream.output_queue.push(('end', None))
- return
-# GPU 装飾器付き処理関数（Spaces用）
-if IN_HF_SPACE:
- @spaces.GPU
-def process_with_gpu(input_image, prompt, n_prompt, seed,
- total_second_length, latent_window_size, steps,
- cfg, gs, rs, gpu_memory_preservation, use_teacache):
- """
- Hugging Face Spaces GPU上でのプロセス関数。
- """
- global stream
- stream = AsyncStream()
- threading.Thread(
- target=async_run,
- args=(worker, input_image, prompt, n_prompt, seed,
- total_second_length, latent_window_size, steps,
- cfg, gs, rs, gpu_memory_preservation, use_teacache)
- ).start()
-
- output_filename = None
- prev_output = None
- error_msg = None
-
- while True:
- flag, data = stream.output_queue.next()
- if flag == 'file':
- output_filename = data
- prev_output = data
- yield data, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive(True))
- elif flag == 'progress':
- preview, desc, html = data
- yield gr.update(), preview, desc, html, gr.update(interactive=False), gr.update(interactive(True))
- elif flag == 'error':
- error_msg = data
- elif flag == 'end':
- if error_msg:
- yield prev_output, gr.update(visible=False), gr.update(), f'{error_msg}
', gr.update(interactive(True)), gr.update(interactive(False))
- else:
- yield prev_output, gr.update(visible=False), gr.update(), '', gr.update(interactive(True)), gr.update(interactive(False))
- break
+def end_process():
+ """生成プロセスを停止する関数 - キューに'end'信号を送信して生成を中断します"""
+ print("【デバッグ】ユーザーが停止ボタンをクリックしました。停止信号を送信中...")
+ # streamが初期化されていることを確認
+ if 'stream' in globals() and stream is not None:
+ # 送信前にキューの状態を確認
+ try:
+ current_top = stream.input_queue.top()
+ print(f"【デバッグ】現在のキュー先頭信号: {current_top}")
+ except Exception as e:
+ print(f"【デバッグ】キュー状態確認中にエラー: {e}")
+
+ # end信号を送信
+ try:
+ stream.input_queue.push('end')
+ print("【デバッグ】キューにend信号を正常に送信しました")
+
+ # 信号が正常に送信されたか確認
+ try:
+ current_top_after = stream.input_queue.top()
+ print(f"【デバッグ】送信後のキュー先頭信号: {current_top_after}")
+ except Exception as e:
+ print(f"【デバッグ】送信後のキュー状態確認中にエラー: {e}")
+
+ except Exception as e:
+ print(f"【デバッグ】キューへのend信号送信に失敗: {e}")
+ else:
+ print("【デバッグ】警告: streamが初期化されていないため、停止信号を送信できません")
+ return None
-def process(*args):
- """
- GPU装飾器なしの通常処理関数。
- """
- return process_with_gpu(*args)
+quick_prompts = [
+ 'The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view',
+]
+quick_prompts = [[x] for x in quick_prompts]
-def end_process():
- """
- 生成処理を中断する関数。
- """
- global stream
- if stream:
- stream.input_queue.push('end')
- return None
-# ---- Gradio UI 定義 ----
-# カスタムCSSを定義（省略せず記載）
+# カスタムCSSを作成し、レスポンシブレイアウトのサポートを追加
def make_custom_css():
- """カスタムCSSを返します。レスポンシブ対応とエラー表示用スタイルを含む"""
- combined_css = """
- /* CSS内容をここに全て記載 */
+ progress_bar_css = make_progress_bar_css()
+
+ responsive_css = """
+ /* 基本レスポンシブ設定 */
+ #app-container {
+ max-width: 100%;
+ margin: 0 auto;
+ }
+
+ /* 言語切り替えボタ��のスタイル */
+ #language-toggle {
+ position: fixed;
+ top: 10px;
+ right: 10px;
+ z-index: 1000;
+ background-color: rgba(0, 0, 0, 0.7);
+ color: white;
+ border: none;
+ border-radius: 4px;
+ padding: 5px 10px;
+ cursor: pointer;
+ font-size: 14px;
+ }
+
+ /* ページタイトルのスタイル */
+ h1 {
+ font-size: 2rem;
+ text-align: center;
+ margin-bottom: 1rem;
+ }
+
+ /* ボタンのスタイル */
+ .start-btn, .stop-btn {
+ min-height: 45px;
+ font-size: 1rem;
+ }
+
+ /* モバイルデバイスのスタイル - 小画面 */
+ @media (max-width: 768px) {
+ h1 {
+ font-size: 1.5rem;
+ margin-bottom: 0.5rem;
+ }
+
+ /* 単一カラムレイアウト */
+ .mobile-full-width {
+ flex-direction: column !important;
+ }
+
+ .mobile-full-width > .gr-block {
+ min-width: 100% !important;
+ flex-grow: 1;
+ }
+
+ /* 動画サイズの調整 */
+ .video-container {
+ height: auto !important;
+ }
+
+ /* ボタンサイズの調整 */
+ .button-container button {
+ min-height: 50px;
+ font-size: 1rem;
+ touch-action: manipulation;
+ }
+
+ /* スライダーの調整 */
+ .slider-container input[type="range"] {
+ height: 30px;
+ }
+ }
+
+ /* タブレットデバイスのスタイル */
+ @media (min-width: 769px) and (max-width: 1024px) {
+ .tablet-adjust {
+ width: 48% !important;
+ }
+ }
+
+ /* ダークモードサポート */
+ @media (prefers-color-scheme: dark) {
+ .dark-mode-text {
+ color: #f0f0f0;
+ }
+
+ .dark-mode-bg {
+ background-color: #2a2a2a;
+ }
+ }
+
+ /* アクセシビリティの向上 */
+ button, input, select, textarea {
+ font-size: 16px; /* iOSでの拡大を防止 */
+ }
+
+ /* タッチ操作の最適化 */
+ button, .interactive-element {
+ min-height: 44px;
+ min-width: 44px;
+ }
+
+ /* コントラストの向上 */
+ .high-contrast {
+ color: #fff;
+ background-color: #000;
+ }
+
+ /* プログレスバーのスタイル強化 */
+ .progress-container {
+ margin-top: 10px;
+ margin-bottom: 10px;
+ }
+
+ /* エラーメッセージのスタイル */
+ #error-message {
+ color: #ff4444;
+ font-weight: bold;
+ padding: 10px;
+ border-radius: 4px;
+ margin-top: 10px;
+ }
+
+ /* エラーコンテナの正しい表示 */
+ .error-message {
+ background-color: rgba(255, 0, 0, 0.1);
+ padding: 10px;
+ border-radius: 4px;
+ margin-top: 10px;
+ border: 1px solid #ffcccc;
+ }
+
+ /* 多言語エラーメッセージの処理 */
+ .error-msg-en, .error-msg-ja {
+ font-weight: bold;
+ }
+
+ /* エラーアイコン */
+ .error-icon {
+ color: #ff4444;
+ font-size: 18px;
+ margin-right: 8px;
+ }
+
+ /* 空のエラーメッセージが背景とボーダーを表示しないことを確認 */
+ #error-message:empty {
+ background-color: transparent;
+ border: none;
+ padding: 0;
+ margin: 0;
+ }
+
+ /* Gradioのデフォルトエラー表示の修正 */
+ .error {
+ display: none !important;
+ }
"""
+
+ # CSSを結合
+ combined_css = progress_bar_css + responsive_css
return combined_css
+
css = make_custom_css()
block = gr.Blocks(css=css).queue()
with block:
- # タイトル
- gr.Markdown("# FramePack - 画像から動画生成")
-
- with gr.Row():
- with gr.Column():
+ # 言語切り替え機能を追加
+ gr.HTML("""
+
+
+
+
+ """)
+
+ # タイトルにはJavaScriptで切り替えられるようにdata-i18n属性を使用
+ gr.HTML("FramePack - 画像から動画生成
")
+
+ # mobile-full-widthクラスを持つレスポンシブ行を使用
+ with gr.Row(elem_classes="mobile-full-width"):
+ with gr.Column(scale=1, elem_classes="mobile-full-width"):
+ # 二言語ラベルを追加 - 画像アップロード
input_image = gr.Image(
- source='upload',
- type='numpy',
- label='画像をアップロード',
+ sources='upload',
+ type="numpy",
+ label="画像をアップロード / Upload Image",
+ elem_id="input-image",
height=320
)
+
+ # 二言語ラベルを追加 - プロンプト
prompt = gr.Textbox(
- label='プロンプト',
- placeholder='The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view'
+ label="プロンプト / Prompt",
+ value='',
+ elem_id="prompt-input"
)
- quick = gr.Dataset(
- samples=[['The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view']],
- label='クイックプロンプト',
- samples_per_page=10,
+
+ # 二言語ラベルを追加 - クイックプロンプト
+ example_quick_prompts = gr.Dataset(
+ samples=quick_prompts,
+ label='クイックプロンプト一覧 / Quick Prompts',
+ samples_per_page=1000,
components=[prompt]
)
- quick.click(lambda x: x[0], inputs=[quick], outputs=prompt)
-
- with gr.Row():
- start_btn = gr.Button('生成開始', variant='primary')
- stop_btn = gr.Button('生成停止', interactive=False)
-
- seed = gr.Number(label='シード値', value=31337, precision=0)
- length = gr.Slider(label='動画の長さ (最大5秒)', minimum=1, maximum=5, value=5, step=0.1)
- steps_slider = gr.Slider(label='推論ステップ数', minimum=1, maximum=100, value=25, step=1)
- teacache = gr.Checkbox(label='TeaCacheを使用', value=True,
- info='高速化しますが、手指の生成品質が若干低下する可能性があります。')
-
- with gr.Column():
- preview = gr.Image(label='プレビュー', visible=False, height=200)
- result = gr.Video(label='生成された動画', autoplay=True, loop=True, height=512)
- progress_desc = gr.Markdown('')
- progress_bar = gr.HTML('')
- error_html = gr.HTML('', visible=True)
-
- start_btn.click(fn=process, inputs=[input_image, prompt, None, seed, length, None, steps_slider, None, None, None, None, teacache],
- outputs=[result, preview, progress_desc, progress_bar, start_btn, stop_btn])
- stop_btn.click(fn=end_process)
-
-# アプリ起動
-type(block.launch())
+ example_quick_prompts.click(lambda x: x[0], inputs=[example_quick_prompts], outputs=prompt, show_progress=False, queue=False)
+
+ # スタイルと二言語ラベルを追加したボタン
+ with gr.Row(elem_classes="button-container"):
+ start_button = gr.Button(
+ value="生成開始 / Generate",
+ elem_classes="start-btn",
+ elem_id="start-button",
+ variant="primary"
+ )
+
+ end_button = gr.Button(
+ value="停止 / Stop",
+ elem_classes="stop-btn",
+ elem_id="stop-button",
+ interactive=False
+ )
+
+ # パラメータ設定エリア
+ with gr.Group():
+ use_teacache = gr.Checkbox(
+ label='TeaCacheを使用 / Use TeaCache',
+ value=True,
+ info='処理速度が速くなりますが、指や手の生成品質が若干低下する可能性があります。 / Faster speed, but may result in slightly worse finger and hand generation.'
+ )
+
+ n_prompt = gr.Textbox(label="ネガティブプロンプト / Negative Prompt", value="", visible=False) # 使用しない
+
+ seed = gr.Number(
+ label="シード値 / Seed",
+ value=31337,
+ precision=0
+ )
+
+ # タッチ操作を最適化するためにslider-containerクラスを追加
+ with gr.Group(elem_classes="slider-container"):
+ total_second_length = gr.Slider(
+ label="動画の長さ（最大5秒） / Video Length (max 5 seconds)",
+ minimum=1,
+ maximum=5,
+ value=5,
+ step=0.1
+ )
+
+ latent_window_size = gr.Slider(
+ label="潜在窓サイズ / Latent Window Size",
+ minimum=1,
+ maximum=33,
+ value=9,
+ step=1,
+ visible=False
+ )
+
+ steps = gr.Slider(
+ label="推論ステップ数 / Inference Steps",
+ minimum=1,
+ maximum=100,
+ value=25,
+ step=1,
+ info='この値の変更は推奨されません。 / Changing this value is not recommended.'
+ )
+
+ cfg = gr.Slider(
+ label="CFGスケール / CFG Scale",
+ minimum=1.0,
+ maximum=32.0,
+ value=1.0,
+ step=0.01,
+ visible=False
+ )
+
+ gs = gr.Slider(
+ label="蒸留CFGスケール / Distilled CFG Scale",
+ minimum=1.0,
+ maximum=32.0,
+ value=10.0,
+ step=0.01,
+ info='この値の変更は推奨されません。 / Changing this value is not recommended.'
+ )
+
+ rs = gr.Slider(
+ label="CFGリスケール / CFG Rescale",
+ minimum=0.0,
+ maximum=1.0,
+ value=0.0,
+ step=0.01,
+ visible=False
+ )
+
+ gpu_memory_preservation = gr.Slider(
+ label="GPU推論保存メモリ(GB) / GPU Memory (GB)",
+ minimum=6,
+ maximum=128,
+ value=6,
+ step=0.1,
+ info="OOMエラーが発生した場合は、この値を大きくしてください。値が大きいほど処理が遅くなります。 / Set this to a larger value if you encounter OOM errors. Larger values cause slower speed."
+ )
+
+ # 右側のプレビューと結果カラム
+ with gr.Column(scale=1, elem_classes="mobile-full-width"):
+ # プレビュー画像
+ preview_image = gr.Image(
+ label="プレビュー / Preview",
+ height=200,
+ visible=False,
+ elem_classes="preview-container"
+ )
+
+ # 動画結果コンテナ
+ result_video = gr.Video(
+ label="生成された動画 / Generated Video",
+ autoplay=True,
+ show_share_button=True, # 共有ボタンを追加
+ height=512,
+ loop=True,
+ elem_classes="video-container",
+ elem_id="result-video"
+ )
+
+ # 二言語説明
+ gr.HTML("注意：逆順サンプリングのため、終了動作が開始動作より先に生成されます。開始動作が動画に表示されていない場合は、しばらくお待ちください。後で生成されます。
")
+
+ # 進捗インジケーター
+ with gr.Group(elem_classes="progress-container"):
+ progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
+ progress_bar = gr.HTML('', elem_classes='no-generating-animation')
+
+ # エラーメッセージエリア - カスタムエラーメッセージ形式をサポートするHTMLコンポーネントを使用
+ error_message = gr.HTML('', elem_id='error-message', visible=True)
+
+ # 処理関数
+ ips = [input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache]
+
+ # 開始と終了ボタンのイベント
+ start_button.click(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])
+ end_button.click(fn=end_process)
+
+
+block.launch()
+
+# わかりやすいエラー表示HTMLを作成
+def create_error_html(error_msg, is_timeout=False):
+ """二言語のエラーメッセージHTMLを作成"""
+ # より親切な日英両言語のエラーメッセージを提供
+ en_msg = ""
+ ja_msg = ""
+
+ if is_timeout:
+ en_msg = "Processing timed out, but partial video may have been generated" if "部分的な動画" in error_msg else f"Processing timed out: {error_msg}"
+ ja_msg = "処理がタイムアウトしましたが、部分的な動画は生成されている可能性があります" if "部分的な動画" in error_msg else f"処理がタイムアウトしました: {error_msg}"
+ elif "モデル読み込み失敗" in error_msg:
+ en_msg = "Failed to load models. The Space may be experiencing high traffic or GPU issues."
+ ja_msg = "モデルの読み込みに失敗しました。Spaceの利用が集中しているか、GPU関連の問題が発生している可能性があります。"
+ elif "GPU" in error_msg or "CUDA" in error_msg or "メモリ" in error_msg or "memory" in error_msg:
+ en_msg = "GPU memory insufficient or GPU error. Try increasing GPU memory preservation value or reduce video length."
+ ja_msg = "GPUメモリが不足しているかGPUエラーが発生しています。GPU推論保存メモリの値を大きくするか、動画の長さを短くしてください。"
+ elif "サンプリング中にエラー" in error_msg:
+ if "部分" in error_msg:
+ en_msg = "Error during sampling process, but partial video has been generated."
+ ja_msg = "サンプリング中にエラーが発生しましたが、部分的な動画は生成されています。"
+ else:
+ en_msg = "Error during sampling process. Unable to generate video."
+ ja_msg = "サンプリング中にエラーが発生し、動画を生成できませんでした。"
+ elif "モデルダウンロードタイムアウト" in error_msg or "ネットワーク接続不安定" in error_msg or "ReadTimeoutError" in error_msg or "ConnectionError" in error_msg:
+ en_msg = "Network connection is unstable, model download timed out. Please try again later."
+ ja_msg = "ネットワーク接続が不安定で、モデルのダウンロードがタイムアウトしました。後ほど再試行してください。"
+ elif "VAE" in error_msg or "デコード" in error_msg or "decode" in error_msg:
+ en_msg = "Error during video decoding or saving process. Try again with a different seed."
+ ja_msg = "動画のデコードまたは保存中にエラーが発生しました。別のシード値で再試行してください。"
+ else:
+ en_msg = f"Processing error: {error_msg}"
+ ja_msg = f"処理中にエラーが発生しました: {error_msg}"
+
+ # 二言語エラーメッセージHTML - 便利なアイコンを追加し、CSSスタイルが適用されることを確認
+ return f"""
+
+
+ ⚠️ {en_msg}
+
+
+ ⚠️ {ja_msg}
+
+