diff --git "a/oneframe_ichi.py" "b/oneframe_ichi.py"
new file mode 100644--- /dev/null
+++ "b/oneframe_ichi.py"
@@ -0,0 +1,3674 @@
+import os
+import sys
+sys.path.append(os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './submodules/FramePack'))))
+
+# Windows環境で loop再生時に [WinError 10054] の warning が出るのを回避する設定
+import asyncio
+if sys.platform in ('win32', 'cygwin'):
+ asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+# グローバル変数 - 停止フラグと通知状態管理
+user_abort = False
+user_abort_notified = False
+
+# バッチ処理とキュー機能用グローバル変数
+batch_stopped = False # バッチ処理中断フラグ
+
+# テキストエンコード結果のキャッシュ用グローバル変数を初期化
+cached_prompt = None
+cached_n_prompt = None
+cached_llama_vec = None
+cached_llama_vec_n = None
+cached_clip_l_pooler = None
+cached_clip_l_pooler_n = None
+cached_llama_attention_mask = None
+cached_llama_attention_mask_n = None
+queue_enabled = False # キュー機能の有効/無効フラグ
+queue_type = "prompt" # キューのタイプ（"prompt" または "image"）
+prompt_queue_file_path = None # プロンプトキューファイルのパス
+image_queue_files = [] # イメージキューのファイルリスト
+
+from diffusers_helper.hf_login import login
+
+import os
+import random # ランダムシード生成用
+import time
+import traceback # ログ出力用
+import yaml
+import argparse
+import json
+import glob
+import subprocess # フォルダを開くために必要
+from PIL import Image
+
+# PNGメタデータ処理モジュールのインポート
+import sys
+sys.path.append(os.path.abspath(os.path.dirname(__file__)))
+from eichi_utils.png_metadata import (
+ embed_metadata_to_png, extract_metadata_from_png,
+ PROMPT_KEY, SEED_KEY, SECTION_PROMPT_KEY, SECTION_NUMBER_KEY
+)
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--share', action='store_true')
+parser.add_argument("--server", type=str, default='127.0.0.1')
+parser.add_argument("--port", type=int, default=8000)
+parser.add_argument("--inbrowser", action='store_true')
+parser.add_argument("--lang", type=str, default='ja', help="Language: ja, zh-tw, en, ru")
+args = parser.parse_args()
+
+# Load translations from JSON files
+from locales.i18n_extended import (set_lang, translate)
+set_lang(args.lang)
+
+# サーバーがすでに実行中かチェック
+import socket
+def is_port_in_use(port):
+ """指定ポートが使用中かどうかを確認"""
+ try:
+ with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+ return s.connect_ex(('localhost', port)) == 0
+ except:
+ # エラーが発生した場合はポートが使用されていないと判断
+ return False
+
+# キャッシュ制御設定
+# ローカルファイルの優先的利用を無効化し安定性を向上
+use_cache_files = True # ファイルキャッシュは使用
+first_run = True # 通常は初回起動として扱う
+
+# ポートが使用中の場合は警告を表示
+if is_port_in_use(args.port):
+ print(translate("警告: ポート {0} はすでに使用されています。他のインスタンスが実行中かもしれません。").format(args.port))
+ print(translate("10秒後に処理を続行します..."))
+ first_run = False # 初回実行ではない
+ time.sleep(10) # 10秒待機して続行
+
+try:
+ import winsound
+ HAS_WINSOUND = True
+except ImportError:
+ HAS_WINSOUND = False
+
+if 'HF_HOME' not in os.environ:
+ os.environ['HF_HOME'] = os.path.abspath(os.path.realpath(os.path.join(os.path.dirname(__file__), './hf_download')))
+ print(translate("HF_HOMEを設定: {0}").format(os.environ['HF_HOME']))
+else:
+ print(translate("既存のHF_HOMEを使用: {0}").format(os.environ['HF_HOME']))
+
+# LoRAサポートの確認
+has_lora_support = False
+has_fp8_support = False
+try:
+ import lora_utils
+ from lora_utils.fp8_optimization_utils import check_fp8_support, apply_fp8_monkey_patch
+
+ has_lora_support = True
+ # FP8サポート確認
+ has_e4m3, has_e5m2, has_scaled_mm = check_fp8_support()
+ has_fp8_support = has_e4m3 and has_e5m2
+
+ if has_fp8_support:
+ pass
+ # FP8最適化のモンキーパッチはLoRA適用時に使用される
+ # apply_fp8_monkey_patch()は引数が必要なため、ここでは呼び出さない
+ else:
+ print(translate("LoRAサポートが有効です (FP8最適化はサポートされていません)"))
+except ImportError:
+ print(translate("LoRAサポートが無効です（lora_utilsモジュールがインストールされていません）"))
+
+# 設定管理モジュールをインポート
+from eichi_utils.settings_manager import (
+ get_settings_file_path,
+ get_output_folder_path,
+ initialize_settings,
+ load_settings,
+ save_settings,
+ open_output_folder,
+ load_app_settings_oichi,
+ save_app_settings_oichi
+)
+
+# ログ管理モジュールをインポート
+from eichi_utils.log_manager import (
+ enable_logging, disable_logging, is_logging_enabled,
+ get_log_folder, set_log_folder, open_log_folder,
+ get_default_log_settings, load_log_settings, apply_log_settings
+)
+
+# LoRAプリセット管理モジュールをインポート
+from eichi_utils.lora_preset_manager import (
+ initialize_lora_presets,
+ load_lora_presets,
+ save_lora_preset,
+ load_lora_preset,
+ get_preset_names
+)
+
+import gradio as gr
+from eichi_utils.ui_styles import get_app_css
+import torch
+import einops
+import safetensors.torch as sf
+import numpy as np
+import math
+
+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
+
+# フォルダを開く関数
+def open_folder(folder_path):
+ """指定されたフォルダをOSに依存せず開く"""
+ if not os.path.exists(folder_path):
+ os.makedirs(folder_path, exist_ok=True)
+ print(translate("フォルダを作成しました: {0}").format(folder_path))
+
+ try:
+ if os.name == 'nt': # Windows
+ subprocess.Popen(['explorer', folder_path])
+ elif os.name == 'posix': # Linux/Mac
+ try:
+ subprocess.Popen(['xdg-open', folder_path])
+ except:
+ subprocess.Popen(['open', folder_path])
+ print(translate("フォルダを開きました: {0}").format(folder_path))
+ return True
+ except Exception as e:
+ print(translate("フォルダを開く際にエラーが発生しました: {0}").format(e))
+ return False
+from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
+from diffusers_helper.memory import cpu, gpu, gpu_complete_modules, 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
+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 eichi_utils.ui_styles import get_app_css
+from transformers import SiglipImageProcessor, SiglipVisionModel
+from diffusers_helper.clip_vision import hf_clip_vision_encode
+from diffusers_helper.bucket_tools import find_nearest_bucket
+
+from eichi_utils.transformer_manager import TransformerManager
+from eichi_utils.text_encoder_manager import TextEncoderManager
+
+free_mem_gb = get_cuda_free_memory_gb(gpu)
+high_vram = free_mem_gb > 100
+
+print(translate('Free VRAM {0} GB').format(free_mem_gb))
+print(translate('High-VRAM Mode: {0}').format(high_vram))
+
+# モデルを並列ダウンロードしておく
+from eichi_utils.model_downloader import ModelDownloader
+ModelDownloader().download_original()
+
+# グローバルなモデル状態管理インスタンスを作成（モデルは実際に使用するまでロードしない）
+transformer_manager = TransformerManager(device=gpu, high_vram_mode=high_vram, use_f1_model=False)
+text_encoder_manager = TextEncoderManager(device=gpu, high_vram_mode=high_vram)
+
+# LoRAの状態を確認
+def reload_transformer_if_needed():
+ """transformerモデルが必要に応じてリロードする"""
+ try:
+ # 既存のensure_transformer_stateメソッドを使用する
+ if hasattr(transformer_manager, 'ensure_transformer_state'):
+ return transformer_manager.ensure_transformer_state()
+ # 互換性のために古い方法も維持
+ elif hasattr(transformer_manager, '_needs_reload') and hasattr(transformer_manager, '_reload_transformer'):
+ if transformer_manager._needs_reload():
+ return transformer_manager._reload_transformer()
+ return True
+ return False
+ except Exception as e:
+ print(translate("transformerリロードエラー: {0}").format(e))
+ traceback.print_exc()
+ return False
+
+# 遅延ロード方式に変更 - 起動時にはtokenizerのみロードする
+try:
+ # tokenizerのロードは起動時から行う
+ try:
+ print(translate("tokenizer, tokenizer_2のロードを開始します..."))
+ tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
+ tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
+ print(translate("tokenizer, tokenizer_2のロードが完了しました"))
+ except Exception as e:
+ print(translate("tokenizer, tokenizer_2のロードに失敗しました: {0}").format(e))
+ traceback.print_exc()
+ print(translate("5秒間待機後に再試行します..."))
+ time.sleep(5)
+ tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
+ tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
+
+ # feature_extractorは軽量なのでここでロード
+ try:
+ print(translate("feature_extractorのロードを開始します..."))
+ feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
+ print(translate("feature_extractorのロードが完了しました"))
+ except Exception as e:
+ print(translate("feature_extractorのロードに失敗しました: {0}").format(e))
+ print(translate("再試行します..."))
+ time.sleep(2)
+ feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
+
+ # 他の重いモデルは遅延ロード方式に変更
+ # 変数の初期化だけ行い、実際のロードはworker関数内で行う
+ vae = None
+ text_encoder = None
+ text_encoder_2 = None
+ transformer = None
+ image_encoder = None
+
+ # transformerダウンロードの確保だけは起動時に
+ try:
+ # モデルのダウンロードを確保（実際のロードはまだ行わない）
+ print(translate("モデルのダウンロードを確保します..."))
+ transformer_manager.ensure_download_models()
+ print(translate("モデルのダウンロードを確保しました"))
+ except Exception as e:
+ print(translate("モデルダウンロード確保エラー: {0}").format(e))
+ traceback.print_exc()
+
+except Exception as e:
+ print(translate("初期化エラー: {0}").format(e))
+ print(translate("プログラムを終了します..."))
+ import sys
+ sys.exit(1)
+
+# モデル設定のデフォルト値を定義（実際のモデルロードはworker関数内で行う）
+def setup_vae_if_loaded():
+ global vae
+ if vae is not None:
+ vae.eval()
+ if not high_vram:
+ vae.enable_slicing()
+ vae.enable_tiling()
+ vae.to(dtype=torch.float16)
+ vae.requires_grad_(False)
+ if high_vram:
+ vae.to(gpu)
+
+def setup_image_encoder_if_loaded():
+ global image_encoder
+ if image_encoder is not None:
+ image_encoder.eval()
+ image_encoder.to(dtype=torch.float16)
+ image_encoder.requires_grad_(False)
+ if high_vram:
+ image_encoder.to(gpu)
+
+stream = AsyncStream()
+
+# フォルダ構造を先に定義
+webui_folder = os.path.dirname(os.path.abspath(__file__))
+base_path = webui_folder # endframe_ichiとの互換性のため
+
+# 設定保存用フォルダの設定
+settings_folder = os.path.join(webui_folder, 'settings')
+os.makedirs(settings_folder, exist_ok=True)
+
+# LoRAプリセットの初期化
+from eichi_utils.lora_preset_manager import initialize_lora_presets
+initialize_lora_presets()
+
+# 設定から出力フォルダを取得
+app_settings = load_settings()
+output_folder_name = app_settings.get('output_folder', 'outputs')
+print(translate("設定から出力フォルダを読み込み: {0}").format(output_folder_name))
+
+# ログ設定を読み込み適用
+log_settings = app_settings.get('log_settings', get_default_log_settings())
+print(translate("ログ設定を読み込み: 有効={0}, フォルダ={1}").format(
+ log_settings.get('log_enabled', False),
+ log_settings.get('log_folder', 'logs')
+))
+if log_settings.get('log_enabled', False):
+ # 現在のファイル名を渡す
+ enable_logging(log_settings.get('log_folder', 'logs'), source_name="oneframe_ichi")
+
+# 出力フォルダのフルパスを生成
+outputs_folder = get_output_folder_path(output_folder_name)
+os.makedirs(outputs_folder, exist_ok=True)
+
+# グローバル変数
+g_frame_size_setting = "1フレーム"
+batch_stopped = False # バッチ処理中断フラグ
+queue_enabled = False # キュー機能の有効/無効フラグ
+queue_type = "prompt" # キューのタイプ（"prompt" または "image"）
+prompt_queue_file_path = None # プロンプトキューのファイルパス
+image_queue_files = [] # イメージキューのファイルリスト
+input_folder_name_value = "inputs" # 入力フォルダの名前（デフォルト値）
+
+# イメージキューのための画像ファイルリストを取得する関数（グローバル関数）
+def get_image_queue_files():
+ """入力フォルダから画像ファイルを取得してイメージキューに追加する関数"""
+ global image_queue_files
+
+ # 入力フォルダの設定
+ input_folder = os.path.join(base_path, input_folder_name_value)
+
+ # フォルダが存在しない場合は作成
+ os.makedirs(input_folder, exist_ok=True)
+
+ # すべての画像ファイルを���得
+ image_exts = ['.jpg', '.jpeg', '.png', '.webp', '.bmp']
+ image_files = []
+
+ # 同じファイルが複数回追加されないようにセットを使用
+ file_set = set()
+
+ for ext in image_exts:
+ pattern = os.path.join(input_folder, '*' + ext)
+ for file in glob.glob(pattern):
+ if file not in file_set:
+ file_set.add(file)
+ image_files.append(file)
+
+ pattern = os.path.join(input_folder, '*' + ext.upper())
+ for file in glob.glob(pattern):
+ if file not in file_set:
+ file_set.add(file)
+ image_files.append(file)
+
+ # ファイルを修正日時の昇順でソート
+ image_files.sort(key=lambda x: os.path.getmtime(x))
+
+ print(translate("入力ディレクトリから画像ファイル{0}個を読み込みました").format(len(image_files)))
+
+ image_queue_files = image_files
+ return image_files
+
+# ワーカー関数
+@torch.no_grad()
+def worker(input_image, prompt, n_prompt, seed, steps, cfg, gs, rs,
+ gpu_memory_preservation, use_teacache, lora_files=None, lora_files2=None, lora_scales_text="0.8,0.8,0.8",
+ output_dir=None, use_lora=False, fp8_optimization=False, resolution=640,
+ latent_window_size=9, latent_index=0, use_clean_latents_2x=True, use_clean_latents_4x=True, use_clean_latents_post=True,
+ lora_mode=None, lora_dropdown1=None, lora_dropdown2=None, lora_dropdown3=None, lora_files3=None,
+ batch_index=None, use_queue=False, prompt_queue_file=None,
+ # Kisekaeichi関連のパラメータ
+ use_reference_image=False, reference_image=None,
+ target_index=1, history_index=13, input_mask=None, reference_mask=None):
+
+ # モデル変数をグローバルとして宣言（遅延ロード用）
+ global vae, text_encoder, text_encoder_2, transformer, image_encoder
+ global queue_enabled, queue_type, prompt_queue_file_path, image_queue_files
+ # テキストエンコード結果をキャッシュするグローバル変数
+ global cached_prompt, cached_n_prompt, cached_llama_vec, cached_llama_vec_n, cached_clip_l_pooler, cached_clip_l_pooler_n
+ global cached_llama_attention_mask, cached_llama_attention_mask_n
+
+ # キュー状態のログ出力
+ use_queue_flag = bool(use_queue)
+ queue_type_flag = queue_type
+ if use_queue_flag:
+ print(translate("キュー状態: {0}, タイプ: {1}").format(use_queue_flag, queue_type_flag))
+
+ if queue_type_flag == "prompt" and prompt_queue_file_path is not None:
+ print(translate("プロンプトキューファイルパス: {0}").format(prompt_queue_file_path))
+
+ elif queue_type_flag == "image" and len(image_queue_files) > 0:
+ print(translate("イメージキュー詳細: 画像数={0}, batch_index={1}").format(
+ len(image_queue_files), batch_index))
+
+ job_id = generate_timestamp()
+
+ # 1フレームモード固有の設定
+ total_latent_sections = 1 # 1セクションに固定
+ frame_count = 1 # 1フレームモード
+ # 出力フォルダの設定
+ if output_dir:
+ outputs_folder = output_dir
+ else:
+ # 出力フォルダはwebui内のoutputsに固定
+ outputs_folder = os.path.join(webui_folder, 'outputs')
+
+ os.makedirs(outputs_folder, exist_ok=True)
+
+ # プログレスバーの初期化
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))
+
+ # モデルや中間ファイルなどのキャッシュ利用フラグ
+ use_cached_files = use_cache_files
+
+ try:
+ # LoRA 設定 - ディレクトリ選択モードをサポート
+ current_lora_paths = []
+ current_lora_scales = []
+
+ if use_lora and has_lora_support:
+ print(translate("LoRA情報: use_lora = {0}, has_lora_support = {1}").format(use_lora, has_lora_support))
+ print(translate("LoRAモード: {0}").format(lora_mode))
+
+ if lora_mode == translate("ディレクトリから選択"):
+ # ディレクトリから選択モードの場合
+ lora_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'lora')
+ print(translate("LoRAディレクトリ: {0}").format(lora_dir))
+
+ # ドロップダウンの選択項目を処理
+ dropdown_paths = []
+
+ # 各ドロップダウンからLoRAを追加
+ for dropdown_idx, dropdown_value in enumerate([lora_dropdown1, lora_dropdown2, lora_dropdown3]):
+ dropdown_name = f"LoRA{dropdown_idx+1}"
+ if dropdown_value and dropdown_value != translate("なし"):
+ lora_path = os.path.join(lora_dir, dropdown_value)
+ print(translate("{name}のロード試行: パス={path}").format(name=dropdown_name, path=lora_path))
+ if os.path.exists(lora_path):
+ current_lora_paths.append(lora_path)
+ print(translate("{name}を選択: {path}").format(name=dropdown_name, path=lora_path))
+ else:
+ # パスを修正して再試行（単なるファイル名の場合）
+ if os.path.dirname(lora_path) == lora_dir and not os.path.isabs(dropdown_value):
+ # すでに正しく構築されているので再試行不要
+ pass
+ else:
+ # 直接ファイル名だけで試行
+ lora_path_retry = os.path.join(lora_dir, os.path.basename(str(dropdown_value)))
+ print(translate("{name}を再試行: {path}").format(name=dropdown_name, path=lora_path_retry))
+ if os.path.exists(lora_path_retry):
+ current_lora_paths.append(lora_path_retry)
+ print(translate("{name}を選択 (パス修正後): {path}").format(name=dropdown_name, path=lora_path_retry))
+ else:
+ print(translate("選択された{name}が見つかりません: {file}").format(name=dropdown_name, file=dropdown_value))
+ else:
+ # ファイルアップロードモードの場合
+ # 全LoRAファイルを収集
+ all_lora_files = []
+
+ # 各LoRAファイルを処理
+ for file_idx, lora_file_obj in enumerate([lora_files, lora_files2, lora_files3]):
+ if lora_file_obj is None:
+ continue
+
+ file_name = f"LoRAファイル{file_idx+1}"
+ print(translate("{name}の処理").format(name=file_name))
+
+ if isinstance(lora_file_obj, list):
+ # 複数のファイルが含まれている場合
+ for file in lora_file_obj:
+ if hasattr(file, 'name') and file.name:
+ current_lora_paths.append(file.name)
+ print(translate("{name}: {file}").format(name=file_name, file=os.path.basename(file.name)))
+ else:
+ # 単一のファイル
+ if hasattr(lora_file_obj, 'name') and lora_file_obj.name:
+ current_lora_paths.append(lora_file_obj.name)
+ print(translate("{name}: {file}").format(name=file_name, file=os.path.basename(lora_file_obj.name)))
+
+ # スケール値を処理
+ if current_lora_paths: # LoRAパスがある場合のみ解析
+ try:
+ scales_text = lora_scales_text.strip()
+ scales = [float(scale.strip()) for scale in scales_text.split(',') if scale.strip()]
+ current_lora_scales = scales
+
+ if len(current_lora_scales) < len(current_lora_paths):
+ print(translate("LoRAスケールの数が不足しているため、デフォルト値で補完します"))
+ current_lora_scales.extend([0.8] * (len(current_lora_paths) - len(current_lora_scales)))
+ elif len(current_lora_scales) > len(current_lora_paths):
+ print(translate("LoRAスケールの数が多すぎるため、不要なものを切り捨てます"))
+ current_lora_scales = current_lora_scales[:len(current_lora_paths)]
+
+ # 最終的なLoRAとスケールの対応を表示
+ for i, (path, scale) in enumerate(zip(current_lora_paths, current_lora_scales)):
+ print(translate("LoRA {0}: {1} (スケール: {2})").format(i+1, os.path.basename(path), scale))
+ except Exception as e:
+ print(translate("LoRAスケール解析エラー: {0}").format(e))
+ # デフォルト値で埋める
+ current_lora_scales = [0.8] * len(current_lora_paths)
+ for i, (path, scale) in enumerate(zip(current_lora_paths, current_lora_scales)):
+ print(translate("LoRA {0}: {1} (デフォルトスケール: {2})").format(i+1, os.path.basename(path), scale))
+
+ # -------- LoRA 設定 START ---------
+ # UI設定のuse_loraフラグ値を保存
+ original_use_lora = use_lora
+
+ # UIでLoRA使用が有効になっていた場合、ファイル選択に関わらず強制的に有効化
+ if original_use_lora:
+ use_lora = True
+
+ # LoRA設定のみを更新
+ transformer_manager.set_next_settings(
+ lora_paths=current_lora_paths,
+ lora_scales=current_lora_scales,
+ high_vram_mode=high_vram,
+ fp8_enabled=fp8_optimization, # fp8_enabledパラメータを追加
+ force_dict_split=True # 常に辞書分割処理を行う
+ )
+ # -------- LoRA 設定 END ---------
+
+ # セクション処理開始前にtransformerの状態を確認
+ print(translate("LoRA適用前のtransformer状態チェック..."))
+ try:
+ # transformerの状態を確認し、必要に応じてリロード
+ if not transformer_manager.ensure_transformer_state():
+ raise Exception(translate("transformer状態の確認に失敗しました"))
+
+ # 最新のtransformerインスタンスを取得
+ transformer = transformer_manager.get_transformer()
+ print(translate("transformer状態チェック完了"))
+ except Exception as e:
+ print(translate("transformerのリロードに失敗しました: {0}").format(e))
+ traceback.print_exc()
+ raise Exception(translate("transformerのリロードに失敗しました"))
+
+ # 入力画像の処理
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Image processing ...'))))
+
+ # 入力画像がNoneの場合はデフォルトの黒い画像を作成
+ if input_image is None:
+ print(translate("入力画像が指定されていないため、黒い画像を生成します"))
+ # 指定された解像度の黒い画像を生成（デフォルトは640x640）
+ height = width = resolution
+ input_image = np.zeros((height, width, 3), dtype=np.uint8)
+ input_image_np = input_image
+ elif isinstance(input_image, str):
+ # 文字列（ファイルパス）の場合は画像をロード
+ print(translate("入力画像がファイルパスのため、画像をロードします: {0}").format(input_image))
+ try:
+ from PIL import Image
+ import numpy as np
+ img = Image.open(input_image)
+ input_image = np.array(img)
+ if len(input_image.shape) == 2: # グレースケール画像の場合
+ input_image = np.stack((input_image,) * 3, axis=-1)
+ elif input_image.shape[2] == 4: # アルファチャンネル付きの場合
+ input_image = input_image[:, :, :3]
+ H, W, C = input_image.shape
+ height, width = find_nearest_bucket(H, W, resolution=resolution)
+ input_image_np = resize_and_center_crop(input_image, target_width=width, target_height=height)
+ except Exception as e:
+ print(translate("画像のロードに失敗しました: {0}").format(e))
+ # エラーが発生した場合はデフォルトの黒い画像を使用
+ import numpy as np
+ height = width = resolution
+ input_image = np.zeros((height, width, 3), dtype=np.uint8)
+ input_image_np = input_image
+ else:
+ # 通常の画像オブジェクトの場合（通常の処理）
+ H, W, C = input_image.shape
+ height, width = find_nearest_bucket(H, W, resolution=resolution)
+ 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}_input.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]
+
+ # VAE エンコーディング
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))
+
+ try:
+ # エンコード前のメモリ状態を記録
+ free_mem_before_encode = get_cuda_free_memory_gb(gpu)
+ print(translate("VAEエンコード前の空きVRAM: {0} GB").format(free_mem_before_encode))
+
+ # VAEモデルのロード（未ロードの場合）
+ if vae is None:
+ print(translate("VAEモデルを初めてロードします..."))
+ try:
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=torch.float16).cpu()
+ setup_vae_if_loaded() # VAEの設定を適用
+ print(translate("VAEモデルのロードが完了しました"))
+ except Exception as e:
+ print(translate("VAEモデルのロードに失敗しました: {0}").format(e))
+ traceback.print_exc()
+ print(translate("5秒間待機後に再試行します..."))
+ time.sleep(5)
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=torch.float16).cpu()
+ setup_vae_if_loaded() # VAEの設定を適用
+
+ # ハイVRAM以外では明示的にモデルをGPUにロード
+ if not high_vram:
+ print(translate("VAEモデルをGPUにロード..."))
+ load_model_as_complete(vae, target_device=gpu)
+
+ # VAEエンコード実行
+ with torch.no_grad(): # 明示的にno_gradコンテキストを使用
+ # 効率的な処理のために入力をGPUで処理
+ input_image_gpu = input_image_pt.to(gpu)
+ start_latent = vae_encode(input_image_gpu, vae)
+
+ # 入力をCPUに戻す
+ del input_image_gpu
+ torch.cuda.empty_cache()
+
+ # ローVRAMモードでは使用後すぐにCPUに戻す
+ if not high_vram:
+ vae.to('cpu')
+
+ # メモリ状態をログ
+ free_mem_after_encode = get_cuda_free_memory_gb(gpu)
+ print(translate("VAEエンコード後の空きVRAM: {0} GB").format(free_mem_after_encode))
+ print(translate("VAEエンコードで使用したVRAM: {0} GB").format(free_mem_before_encode - free_mem_after_encode))
+
+ # メモリクリーンアップ
+ torch.cuda.empty_cache()
+ except Exception as e:
+ print(translate("VAEエンコードエラー: {0}").format(e))
+
+ # エラー発生時のメモリ解放
+ if 'input_image_gpu' in locals():
+ del input_image_gpu
+ torch.cuda.empty_cache()
+
+ raise e
+
+ # 1フレームモード用の設定（sample_num_framesを早期に定義）
+ sample_num_frames = 1 # 1フレームモード（one_frame_inferenceが有効なため）
+ num_frames = sample_num_frames
+ # Kisekaeichi機能: 参照画像の処理
+ reference_latent = None
+ reference_encoder_output = None
+
+ if use_reference_image and reference_image is not None:
+ print(translate("着せ替え参照画像を処理します: {0}").format(reference_image))
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Processing reference image ...'))))
+
+ try:
+ # 参照画像をロード
+ from PIL import Image
+ ref_img = Image.open(reference_image)
+ ref_image_np = np.array(ref_img)
+ if len(ref_image_np.shape) == 2: # グレースケール画像の場合
+ ref_image_np = np.stack((ref_image_np,) * 3, axis=-1)
+ elif ref_image_np.shape[2] == 4: # アルファチャンネル付きの場合
+ ref_image_np = ref_image_np[:, :, :3]
+
+ # 同じサイズにリサイズ（入力画像と同じ解像度を使用）
+ ref_image_np = resize_and_center_crop(ref_image_np, target_width=width, target_height=height)
+ ref_image_pt = torch.from_numpy(ref_image_np).float() / 127.5 - 1
+ ref_image_pt = ref_image_pt.permute(2, 0, 1)[None, :, None]
+
+ # VAEエンコード（参照画像）
+ if vae is None or not high_vram:
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=torch.float16).cpu()
+ setup_vae_if_loaded()
+ load_model_as_complete(vae, target_device=gpu)
+
+ with torch.no_grad(): # 明示的にno_gradコンテキストを使用
+ ref_image_gpu = ref_image_pt.to(gpu)
+ reference_latent = vae_encode(ref_image_gpu, vae)
+ del ref_image_gpu
+
+ if not high_vram:
+ vae.to('cpu')
+
+ # CLIP Visionエンコード（参照画像）
+ if image_encoder is None or not high_vram:
+ if image_encoder is None:
+ image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=torch.float16).cpu()
+ setup_image_encoder_if_loaded()
+ load_model_as_complete(image_encoder, target_device=gpu)
+
+ reference_encoder_output = hf_clip_vision_encode(ref_image_np, feature_extractor, image_encoder)
+
+ if not high_vram:
+ image_encoder.to('cpu')
+
+ print(translate("参照��像の処理が完了しました"))
+
+ except Exception as e:
+ print(translate("参照画像の処理に失敗しました: {0}").format(e))
+ reference_latent = None
+ reference_encoder_output = None
+
+ # CLIP Vision エンコーディング
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
+
+ try:
+ # 画像エンコーダのロード（未ロードの場合）
+ if image_encoder is None:
+ print(translate("画像エンコーダを初めてロードします..."))
+ try:
+ image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=torch.float16).cpu()
+ setup_image_encoder_if_loaded() # 画像エンコーダの設定を適用
+ print(translate("画像エンコーダのロードが完了しました"))
+ except Exception as e:
+ print(translate("画像エンコーダのロードに失敗しました: {0}").format(e))
+ print(translate("再試行します..."))
+ time.sleep(2)
+ image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=torch.float16).cpu()
+ setup_image_encoder_if_loaded() # 画像エンコーダの設定を適用
+
+ if not high_vram:
+ print(translate("画像エンコーダをGPUにロード..."))
+ load_model_as_complete(image_encoder, target_device=gpu)
+
+ # CLIP Vision エンコード実行
+ 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
+
+ # ローVRAMモードでは使用後すぐにCPUに戻す
+ if not high_vram:
+ image_encoder.to('cpu')
+
+ # メモリ状態をログ
+ free_mem_gb = get_cuda_free_memory_gb(gpu)
+ print(translate("CLIP Vision エンコード後の空きVRAM {0} GB").format(free_mem_gb))
+
+ # メモリクリーンアップ
+ torch.cuda.empty_cache()
+ except Exception as e:
+ print(translate("CLIP Vision エンコードエラー: {0}").format(e))
+ raise e
+
+ # テキストエンコーディング
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Text encoding ...'))))
+
+ # イメージキューでカスタムプロンプトを使用しているかどうかを確認
+ using_custom_prompt = False
+ current_prompt = prompt # デフォルトは共通プロンプト
+
+ if queue_enabled and queue_type == "image" and batch_index is not None and batch_index > 0:
+ if batch_index - 1 < len(image_queue_files):
+ queue_img_path = image_queue_files[batch_index - 1]
+ img_basename = os.path.splitext(queue_img_path)[0]
+ txt_path = f"{img_basename}.txt"
+ if os.path.exists(txt_path):
+ try:
+ # テキストファイルからカスタムプロンプトを読み込む
+ with open(txt_path, 'r', encoding='utf-8') as f:
+ custom_prompt = f.read().strip()
+
+ # カスタムプロンプトを設定
+ current_prompt = custom_prompt
+
+ img_name = os.path.basename(queue_img_path)
+ using_custom_prompt = True
+ print(translate("カスタムプロンプト情報: イメージキュー画像「{0}」の専用プロンプトを使用しています").format(img_name))
+ except Exception as e:
+ print(translate("カスタムプロンプトファイルの読み込みに失敗しました: {0}").format(e))
+ using_custom_prompt = False # エラーが発生した場合は共通プロンプトを使用
+
+ # キャッシュの使用判断
+ global cached_prompt, cached_n_prompt, cached_llama_vec, cached_llama_vec_n
+ global cached_clip_l_pooler, cached_clip_l_pooler_n, cached_llama_attention_mask, cached_llama_attention_mask_n
+
+ # プロンプトが変更されたかチェック
+ use_cache = (cached_prompt == prompt and cached_n_prompt == n_prompt and
+ cached_llama_vec is not None and cached_llama_vec_n is not None)
+
+ if use_cache:
+ # キャッシュを使用
+ print(translate("キャッシュされたテキストエンコード���果を使用します"))
+ llama_vec = cached_llama_vec
+ clip_l_pooler = cached_clip_l_pooler
+ llama_vec_n = cached_llama_vec_n
+ clip_l_pooler_n = cached_clip_l_pooler_n
+ llama_attention_mask = cached_llama_attention_mask
+ llama_attention_mask_n = cached_llama_attention_mask_n
+ else:
+ # キャッシュなし - 新規エンコード
+ try:
+ # 常にtext_encoder_managerから最新のテキストエンコーダーを取得する
+ print(translate("テキストエンコーダを初期化します..."))
+ try:
+ # text_encoder_managerを使用して初期化
+ if not text_encoder_manager.ensure_text_encoder_state():
+ print(translate("テキストエンコーダの初期化に失敗しました。再試行します..."))
+ time.sleep(3)
+ if not text_encoder_manager.ensure_text_encoder_state():
+ raise Exception(translate("テキストエンコーダとtext_encoder_2の初期化に複数回失敗しました"))
+ text_encoder, text_encoder_2 = text_encoder_manager.get_text_encoders()
+ print(translate("テキストエンコーダの初期化が完了しました"))
+ except Exception as e:
+ print(translate("テキストエンコーダのロードに失敗しました: {0}").format(e))
+ traceback.print_exc()
+ raise e
+
+ if not high_vram:
+ print(translate("テキストエンコーダをGPUにロード..."))
+ fake_diffusers_current_device(text_encoder, gpu)
+ load_model_as_complete(text_encoder_2, target_device=gpu)
+
+ # テキストエンコーディング実行
+ # 実際に使用されるプロンプトを必ず表示
+ full_prompt = prompt # 実際に使用するプロンプト
+ prompt_source = translate("共通プロンプト") # プロンプトの種類
+
+ # プロンプトソースの判定
+ if queue_enabled and queue_type == "prompt" and batch_index is not None:
+ # プロンプトキューの場合
+ prompt_source = translate("プロンプトキュー")
+ print(translate("プロンプトキューからのプロンプトをエンコードしています..."))
+ elif using_custom_prompt:
+ # イメージキューのカスタムプロンプトの場合
+ full_prompt = current_prompt # カスタムプロンプトを使用
+ prompt_source = translate("カスタムプロンプト")
+ print(translate("カスタムプロンプトをエンコードしています..."))
+ else:
+ # 通常の共通プロンプトの場合
+ print(translate("共通プロンプトをエンコードしています..."))
+
+ # プロンプトの内容とソースを表示
+ print(translate("プロンプトソース: {0}").format(prompt_source))
+ print(translate("プロンプト全文: {0}").format(full_prompt))
+ print(translate("プロンプトをエンコードしています..."))
+ llama_vec, clip_l_pooler = encode_prompt_conds(full_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:
+ print(translate("ネガティブプロンプトをエンコードしています..."))
+ llama_vec_n, clip_l_pooler_n = encode_prompt_conds(n_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
+
+ # ローVRAMモードでは使用後すぐにCPUに戻す
+ if not high_vram:
+ if text_encoder is not None and hasattr(text_encoder, 'to'):
+ text_encoder.to('cpu')
+ if text_encoder_2 is not None and hasattr(text_encoder_2, 'to'):
+ text_encoder_2.to('cpu')
+
+ # メモリ状態をログ
+ free_mem_gb = get_cuda_free_memory_gb(gpu)
+ print(translate("テキストエンコード後の空きVRAM {0} GB").format(free_mem_gb))
+
+ # メモリクリーンアップ
+ torch.cuda.empty_cache()
+
+ # エンコード結果をキャッシュ
+ print(translate("エンコード結果をキャッシュします"))
+ cached_prompt = prompt
+ cached_n_prompt = n_prompt
+
+ # エンコード処理後にキャッシュを更新
+ 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)
+
+ # キャッシュを更新
+ cached_llama_vec = llama_vec
+ cached_llama_vec_n = llama_vec_n
+ cached_clip_l_pooler = clip_l_pooler
+ cached_clip_l_pooler_n = clip_l_pooler_n
+ cached_llama_attention_mask = llama_attention_mask
+ cached_llama_attention_mask_n = llama_attention_mask_n
+
+ except Exception as e:
+ print(translate("テキストエンコードエラー: {0}").format(e))
+ raise e
+
+ # キャッシュを使用する場合は既にcrop_or_pad_yield_maskが適用済み
+ if not use_cache:
+ # キャッシュを使用しない場合のみ適用
+ 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)
+
+ # データ型変換
+ 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)
+
+ # endframe_ichiと同様に、テキストエンコーダーのメモリを完全に解放
+ if not high_vram:
+ print(translate("テキストエンコーダを完全に解放します"))
+ # テキストエンコーダーを完全に解放（endframe_ichiと同様に）
+ text_encoder, text_encoder_2 = None, None
+ text_encoder_manager.dispose_text_encoders()
+ # 明示的なキャッシュクリア
+ torch.cuda.empty_cache()
+
+ # 1フレームモード用の設定
+ stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Start sampling ...'))))
+
+ rnd = torch.Generator("cpu").manual_seed(seed)
+
+ # history_latentsを確実に新規作成（前回実行の影響を排除）
+ history_latents = torch.zeros(size=(1, 16, 1 + 2 + 16, height // 8, width // 8), dtype=torch.float32, device='cpu')
+ history_pixels = None
+ total_generated_latent_frames = 0
+
+ # 1フレームモード用に特別に設定
+ latent_paddings = [0] * total_latent_sections
+
+ for latent_padding in latent_paddings:
+ is_last_section = latent_padding == 0 # 常にTrue
+ latent_padding_size = latent_padding * latent_window_size # 常に0
+
+ if stream.input_queue.top() == 'end':
+ stream.output_queue.push(('end', None))
+ return
+
+ # 1フレームモード用のindices設定
+ # PR実装に合わせて、インデックスの範囲を明示的に設定
+ # 元のPRでは 0から total_frames相当の値までのインデックスを作成
+ # 1フレームモードでは通常: [0(clean_pre), 1(latent), 2(clean_post), 3,4(clean_2x), 5-20(clean_4x)]
+ indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)
+ split_sizes = [1, latent_padding_size, latent_window_size, 1, 2, 16]
+
+ # latent_padding_sizeが0の場合、空のテンソルになる可能性があるため処理を調整
+ if latent_padding_size == 0:
+ # blank_indicesを除いて分割
+ clean_latent_indices_pre = indices[:, 0:1]
+ latent_indices = indices[:, 1:1+latent_window_size]
+ clean_latent_indices_post = indices[:, 1+latent_window_size:2+latent_window_size]
+ clean_latent_2x_indices = indices[:, 2+latent_window_size:4+latent_window_size]
+ clean_latent_4x_indices = indices[:, 4+latent_window_size:20+latent_window_size]
+ blank_indices = torch.empty((1, 0), dtype=torch.long) # 空のテンソル
+ else:
+ clean_latent_indices_pre, blank_indices, latent_indices, clean_latent_indices_post, clean_latent_2x_indices, clean_latent_4x_indices = indices.split(split_sizes, dim=1)
+
+ # 公式実装に完全に合わせたone_frame_inference処理
+ if sample_num_frames == 1:
+ # 1フレームモードの特別な処理
+ if use_reference_image:
+ # kisekaeichi用の設定（公式実装）
+ one_frame_inference = set()
+ one_frame_inference.add(f"target_index={target_index}")
+ one_frame_inference.add(f"history_index={history_index}")
+
+ # 公式実装に従った処理
+ latent_indices = indices[:, -1:] # デフォルトは最後のフレーム
+
+ # パラメータ解析と処理（公式実装と同じ）
+ for one_frame_param in one_frame_inference:
+ if one_frame_param.startswith("target_index="):
+ target_idx = int(one_frame_param.split("=")[1])
+ latent_indices[:, 0] = target_idx
+
+ elif one_frame_param.startswith("history_index="):
+ history_idx = int(one_frame_param.split("=")[1])
+ clean_latent_indices_post[:, 0] = history_idx
+ else:
+ # 通常モード（参照画像なし）- 以前の動作を復元
+ # 正常動作版と同じように、latent_window_size内の最後のインデックスを使用
+ all_indices = torch.arange(0, latent_window_size).unsqueeze(0)
+ latent_indices = all_indices[:, -1:]
+
+ else:
+ # 通常のモード（複数フレーム）
+ # 詳細設定のlatent_indexに基づいたインデックス処理
+ all_indices = torch.arange(0, latent_window_size).unsqueeze(0)
+ if latent_index > 0 and latent_index < latent_window_size:
+ # ユーザー指定のインデックスを使用
+ latent_indices = all_indices[:, latent_index:latent_index+1]
+ else:
+ # デフォルトは最後のインデックス
+ latent_indices = all_indices[:, -1:]
+
+ # clean_latents設定
+ clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)
+
+ # 通常モードでのインデックス調整
+ if not use_reference_image and sample_num_frames == 1:
+ # 通常モードではすべてのインデックスを単純化
+ clean_latent_indices = torch.tensor([[0]], dtype=clean_latent_indices.dtype, device=clean_latent_indices.device)
+
+ # clean_latents_2xとclean_latents_4xも調整
+ if clean_latent_2x_indices.shape[1] > 0:
+ # clean_latents_2xの最初の要素のみを使用
+ clean_latent_2x_indices = clean_latent_2x_indices[:, :1]
+
+ if clean_latent_4x_indices.shape[1] > 0:
+ # clean_latents_4xの最初の要素のみを使用
+ clean_latent_4x_indices = clean_latent_4x_indices[:, :1]
+
+ # start_latentの形状を確認
+ if len(start_latent.shape) < 5: # バッチとフレーム次元がない場合
+ # [B, C, H, W] → [B, C, 1, H, W] の形に変換
+ clean_latents_pre = start_latent.unsqueeze(2).to(history_latents.dtype).to(history_latents.device)
+ else:
+ clean_latents_pre = start_latent.to(history_latents.dtype).to(history_latents.device)
+
+ # history_latentsからデータを適切に分割
+ try:
+ # 分割前に形状確認
+ frames_to_split = history_latents.shape[2]
+
+ if frames_to_split >= 19: # 1+2+16フレームを想定
+ # 正常分割
+ clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, :1 + 2 + 16, :, :].split([1, 2, 16], dim=2)
+ else:
+ # フレーム数が不足している場合は適切なサイズで初期化
+ clean_latents_post = torch.zeros(1, 16, 1, height // 8, width // 8, dtype=history_latents.dtype, device=history_latents.device)
+ clean_latents_2x = torch.zeros(1, 16, 2, height // 8, width // 8, dtype=history_latents.dtype, device=history_latents.device)
+ clean_latents_4x = torch.zeros(1, 16, 16, height // 8, width // 8, dtype=history_latents.dtype, device=history_latents.device)
+ except Exception as e:
+ print(translate("history_latentsの分割中にエラー: {0}").format(e))
+ # エラー発生時はゼロで初期化
+ clean_latents_post = torch.zeros(1, 16, 1, height // 8, width // 8, dtype=torch.float32, device='cpu')
+ clean_latents_2x = torch.zeros(1, 16, 2, height // 8, width // 8, dtype=torch.float32, device='cpu')
+ clean_latents_4x = torch.zeros(1, 16, 16, height // 8, width // 8, dtype=torch.float32, device='cpu')
+
+ # 公式実装のno_2x, no_4x処理を先に実装
+ if sample_num_frames == 1 and use_reference_image:
+ # kisekaeichi時の固定設定（公式実装に完全準拠）
+ one_frame_inference = set()
+ one_frame_inference.add(f"target_index={target_index}")
+ one_frame_inference.add(f"history_index={history_index}")
+
+ # 公式実装のオプション処理（no_post以外）
+ for option in one_frame_inference:
+ if option == "no_2x":
+ clean_latents_2x = None
+ clean_latent_2x_indices = None
+
+ elif option == "no_4x":
+ clean_latents_4x = None
+ clean_latent_4x_indices = None
+
+ # 詳細設定のオプションに基づいて処理
+ if use_clean_latents_post:
+ try:
+ # 正しい形状に変換して結合
+ if len(clean_latents_pre.shape) != len(clean_latents_post.shape):
+ # 形状を合わせる
+ if len(clean_latents_pre.shape) < len(clean_latents_post.shape):
+ clean_latents_pre = clean_latents_pre.unsqueeze(2)
+ else:
+ clean_latents_post = clean_latents_post.unsqueeze(1)
+
+ # 結合
+ clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)
+ except Exception as e:
+ print(translate("clean_latentsの結合中にエラーが発生しました: {0}").format(e))
+ print(translate("前処理のみを使用します"))
+ clean_latents = clean_latents_pre
+ if len(clean_latents.shape) == 4: # [B, C, H, W]
+ clean_latents = clean_latents.unsqueeze(2) # [B, C, 1, H, W]
+ else:
+ print(translate("clean_latents_postは無効化されています。生成が高速化されますが、ノイズが増える可能性があります"))
+ # clean_latents_postを使用しない場合、前処理+空白レイテント（ゼロテンソル）を結合
+ # これはオリジナルの実装をできるだけ維持しつつ、エラーを回避するためのアプローチ
+ clean_latents_pre_shaped = clean_latents_pre
+ if len(clean_latents_pre.shape) == 4: # [B, C, H, W]
+ clean_latents_pre_shaped = clean_latents_pre.unsqueeze(2) # [B, C, 1, H, W]
+
+ # 空のレイテントを作成（形状を合わせる）
+ shape = list(clean_latents_pre_shaped.shape)
+ # [B, C, 1, H, W]の形状に対して、[B, C, 1, H, W]の空テンソルを作成
+ empty_latent = torch.zeros_like(clean_latents_pre_shaped)
+
+ # 結合して形状を維持
+ clean_latents = torch.cat([clean_latents_pre_shaped, empty_latent], dim=2)
+
+ # no_post処理をclean_latentsが定義された後に実行
+ if sample_num_frames == 1 and use_reference_image and 'one_frame_inference' in locals():
+ for option in one_frame_inference:
+ if option == "no_post":
+ if clean_latents is not None:
+ clean_latents = clean_latents[:, :, :1, :, :]
+ clean_latent_indices = clean_latent_indices[:, :1]
+
+ # transformerの初期化とロード（未ロードの場合）
+ if transformer is None:
+ try:
+ # transformerの状態を確認
+ if not transformer_manager.ensure_transformer_state():
+ raise Exception(translate("transformer状態の確認に失敗しました"))
+
+ # transformerインスタンスを取得
+ transformer = transformer_manager.get_transformer()
+ except Exception as e:
+ print(translate("transformerのロードに失敗しました: {0}").format(e))
+ traceback.print_exc()
+
+ if not transformer_manager.ensure_transformer_state():
+ raise Exception(translate("transformer状態の再確認に失敗しました"))
+
+ transformer = transformer_manager.get_transformer()
+
+ # endframe_ichiと同様にtransformerをGPUに移動
+ # vae, text_encoder, text_encoder_2, image_encoderをCPUに移動し、メモリを解放
+ if not high_vram:
+ # GPUメモリの解放 - transformerは処理中に必要なので含めない
+ unload_complete_models(
+ text_encoder, text_encoder_2, image_encoder, vae
+ )
+
+ # FP8最適化の有無に関わらず、gpu_complete_modulesに登録してから移動
+ if transformer not in gpu_complete_modules:
+ # endframe_ichiと同様に、unload_complete_modulesで確実に解放されるようにする
+ gpu_complete_modules.append(transformer)
+
+ # メモリ確保した上でGPUへ移動
+ # GPUメモリ保存値を明示的に浮動小数点に変換
+ preserved_memory = float(gpu_memory_preservation) if gpu_memory_preservation is not None else 6.0
+ move_model_to_device_with_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=preserved_memory)
+ else:
+ # ハイVRAMモードでも正しくロードしてgpu_complete_modulesに追加
+ load_model_as_complete(transformer, target_device=gpu, unload=True)
+
+ # teacacheの設定
+ if use_teacache:
+ transformer.initialize_teacache(enable_teacache=True, num_steps=steps)
+ else:
+ transformer.initialize_teacache(enable_teacache=False)
+
+ def callback(d):
+ try:
+ 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')
+
+ if stream.input_queue.top() == 'end':
+ # グローバル変数を直接設定
+ global batch_stopped, user_abort, user_abort_notified
+ batch_stopped = True
+ user_abort = True
+
+ # 通知は一度だけ行うようにする - user_abort_notifiedが設定されていない場合のみ表示
+ # 通常は既にend_process()内で設定済みなのでここでは表示されない
+ if not user_abort_notified:
+ user_abort_notified = True
+
+ # 中断検出をoutput_queueに通知
+ stream.output_queue.push(('end', None))
+
+ # 戻り値に特殊値を設定して上位処理で検知できるようにする
+ return {'user_interrupt': True}
+
+ current_step = d['i'] + 1
+ percentage = int(100.0 * current_step / steps)
+ hint = f'Sampling {current_step}/{steps}'
+ desc = translate('1フレームモード: サンプリング中...')
+ stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
+ except KeyboardInterrupt:
+ # 例外を再スローしない - 戻り値で制御
+ return {'user_interrupt': True}
+ except Exception as e:
+ import traceback
+
+ # 異常な次元数を持つテンソルを処理
+ try:
+ if len(clean_latents_2x.shape) > 5:
+ # エラーメッセージは[1, 16, 1, 1, 96, 64]のような6次元テンソルを示しています
+ # 必要なのは5次元テンソル[B, C, T, H, W]です
+ if clean_latents_2x.shape[2] == 1 and clean_latents_2x.shape[3] == 1:
+ # 余分な次元を削除
+ clean_latents_2x = clean_latents_2x.squeeze(2) # [1, 16, 1, 96, 64]
+ except Exception as e:
+ print(translate("clean_latents_2xの形状調整中にエラー: {0}").format(e))
+
+ try:
+ if len(clean_latents_4x.shape) > 5:
+ if clean_latents_4x.shape[2] == 1 and clean_latents_4x.shape[3] == 1:
+ # 余分な次元を削除
+ clean_latents_4x = clean_latents_4x.squeeze(2) # [1, 16, 1, 96, 64]
+ except Exception as e:
+ print(translate("clean_latents_4xの形状調整中にエラー: {0}").format(e))
+
+ # 通常モードの処理（参照画像なし）
+ if not use_reference_image:
+ # 入力画像がindex 0にあることを確認
+ if clean_latents.shape[2] > 0:
+ pass
+
+ # Kisekaeichi機能: 参照画像latentの設定
+ elif use_reference_image and reference_latent is not None:
+
+ # kisekaeichi仕様：入力画像からサンプリングし、参照画像の特徴を使用
+ # clean_latentsの形状が [B, C, 2, H, W] の場合
+ if clean_latents.shape[2] >= 2:
+ # clean_latentsの配置を確実にする
+ # index 0: サンプリング開始点（入力画像）
+ # index 1: 参照画像（特徴転送用）
+
+ # すでにclean_latents_preが入力画像なので、index 0は変更不要
+ # index 1に参照画像を設定
+ clean_latents[:, :, 1] = reference_latent[:, :, 0]
+
+ # kisekaeichi: 潜在空間での特徴転送の準備
+ # ブレンドではなく、denoisingプロセス中にAttention機構で転送される
+ # マスクがある場合のみ、マスクに基づいた潜在空間の調整を行う
+
+ else:
+ print(translate("clean_latentsの形状が予期しない形式です: {0}").format(clean_latents.shape))
+
+ # clean_latent_indicesも更新する必要がある
+ if clean_latent_indices.shape[1] > 1:
+ # PRの実装に従い、history_indexをそのまま使用
+ clean_latent_indices[:, 1] = history_index
+ else:
+ print(translate("clean_latent_indicesの形状が予期しない形式です: {0}").format(clean_latent_indices.shape))
+
+ # 公式実装に従い、target_indexを設定
+ if latent_indices.shape[1] > 0:
+ # latent_window_sizeに基づいて調整（現在は9）
+ max_latent_index = latent_window_size - 1
+ target_index_actual = min(target_index, max_latent_index) # 範囲内に制限
+ latent_indices[:, 0] = target_index_actual
+ print(translate("target_indexを{0}に設定しました（最大値: {1}）").format(target_index_actual, max_latent_index))
+ else:
+ print(translate("latent_indicesが空です"))
+
+ # 参照画像のCLIP Vision出力は直接使用しない（エラー回避のため）
+ # latentレベルでの変更のみ適用
+ if reference_encoder_output is not None:
+ print(translate("参照画像の特徴はlatentのみで反映されます"))
+
+ # マスクの適用（kisekaeichi仕様）
+ if input_mask is not None or reference_mask is not None:
+ print(translate("kisekaeichi: マスクを適用します"))
+ try:
+ from PIL import Image
+ import numpy as np
+
+ # 潜在空間のサイズ
+ height_latent, width_latent = clean_latents.shape[-2:]
+
+ # 入力画像マスクの処理
+ if input_mask is not None:
+ input_mask_img = Image.open(input_mask).convert('L')
+ input_mask_np = np.array(input_mask_img)
+ input_mask_resized = Image.fromarray(input_mask_np).resize((width_latent, height_latent), Image.BILINEAR)
+ input_mask_tensor = torch.from_numpy(np.array(input_mask_resized)).float() / 255.0
+ input_mask_tensor = input_mask_tensor.to(clean_latents.device)[None, None, None, :, :]
+
+ # 入力画像のマスクを適用（黒い部分をゼロ化）
+ clean_latents[:, :, 0:1] = clean_latents[:, :, 0:1] * input_mask_tensor
+ print(translate("入力画像マスクを適用しました（黒い領域をゼロ化）"))
+
+ # 参照画像マスクの処理
+ if reference_mask is not None:
+ reference_mask_img = Image.open(reference_mask).convert('L')
+ reference_mask_np = np.array(reference_mask_img)
+ reference_mask_resized = Image.fromarray(reference_mask_np).resize((width_latent, height_latent), Image.BILINEAR)
+ reference_mask_tensor = torch.from_numpy(np.array(reference_mask_resized)).float() / 255.0
+ reference_mask_tensor = reference_mask_tensor.to(clean_latents.device)[None, None, None, :, :]
+
+ # 参照画像のマスクを適用（黒い部分をゼロ化）
+ if clean_latents.shape[2] >= 2:
+ clean_latents[:, :, 1:2] = clean_latents[:, :, 1:2] * reference_mask_tensor
+ print(translate("参照画像マスクを適用しました（黒い領域をゼロ化）"))
+ else:
+ print(translate("参照画像が設定されていません"))
+
+ print(translate("マスク適用完了"))
+
+ except Exception as e:
+ print(translate("マスクの適用に失敗しました: {0}").format(e))
+ else:
+ print(translate("kisekaeichi: マスクが指定されていません"))
+
+ # 公式実装のzero_post処理（固定値として実装）
+ if sample_num_frames == 1:
+ one_frame_inference = set()
+ one_frame_inference.add(f"target_index={target_index}")
+ one_frame_inference.add(f"history_index={history_index}")
+ # 公式実装の推奨動作として、参照画像がない場合にzero_postを適用
+ if not use_reference_image:
+ one_frame_inference.add("zero_post")
+
+ # zero_post処理（公式実装と完全同一）
+ if "zero_post" in one_frame_inference:
+ clean_latents[:, :, 1:, :, :] = torch.zeros_like(clean_latents[:, :, 1:, :, :])
+
+ # 他のオプションも処理
+ for option in one_frame_inference:
+ if option == "no_2x":
+ if 'clean_latents_2x_param' in locals():
+ clean_latents_2x_param = None
+
+ elif option == "no_4x":
+ if 'clean_latents_4x_param' in locals():
+ clean_latents_4x_param = None
+
+ elif option == "no_post":
+ if clean_latents.shape[2] > 1:
+ clean_latents = clean_latents[:, :, :1, :, :]
+
+ # clean_latents_2xとclean_latents_4xの設定に応じて変数を調整
+ # 1フレームモードの調整後の値を使用
+ if num_frames == 1 and use_reference_image:
+ clean_latents_2x_param = clean_latents_2x
+ clean_latents_4x_param = clean_latents_4x
+ else:
+ clean_latents_2x_param = clean_latents_2x if use_clean_latents_2x else None
+ clean_latents_4x_param = clean_latents_4x if use_clean_latents_4x else None
+
+ # 最適化オプションのログ
+ if not use_clean_latents_2x:
+ print(translate("clean_latents_2xは無効化されています。出力画像に変化が発生します"))
+ if not use_clean_latents_4x:
+ print(translate("clean_latents_4xは無効化されています。出力画像に変化が発生します"))
+
+ # RoPE値を設定 - transformer内部のmax_positionを設定してみる
+ print(translate("設定されたRoPE値(latent_window_size): {0}").format(latent_window_size))
+
+ try:
+ # transformerモデルの内部パラメータを調整
+ # HunyuanVideoTransformerモデル内部のmax_positionに相当する値を変更する
+ if hasattr(transformer, 'max_pos_embed_window_size'):
+ original_value = transformer.max_pos_embed_window_size
+ print(translate("元のmax_pos_embed_window_size: {0}").format(original_value))
+ transformer.max_pos_embed_window_size = latent_window_size
+ print(translate("max_pos_embed_window_sizeを{0}に設定しました").format(latent_window_size))
+
+ # RoFormerなどのRoPE実装を探して調整
+ if hasattr(transformer, 'attn_processors'):
+ print(translate("attn_processorsが見つかりました、RoPE関連設定を探します"))
+ # 詳細は出力しない
+
+ # HunyuanVideo特有の実装を探す
+ if hasattr(transformer, 'create_image_rotary_emb'):
+ print(translate("create_image_rotary_embを調整中..."))
+ except Exception as e:
+ print(translate("RoPE値の設定中にエラーが発生しました: {0}").format(e))
+ print(translate("デフォルト値を使用します"))
+
+ # サンプリング前の最終メモリクリア（endframe_ichiと同様）
+ # 不要な変数を明示的に解放
+ image_encoder = None
+ vae = None
+ # 明示的なキャッシュクリア
+ torch.cuda.empty_cache()
+
+ # sample_hunyuan関数呼び出し部分
+ try:
+ # BFloat16に変換（通常の処理）
+ if image_encoder_last_hidden_state is not None:
+ image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(dtype=torch.bfloat16)
+
+ # 参照画像のCLIP Vision特徴を使用する場合は、注意深く処理
+ # 現在の実装では参照画像のCLIP特徴を使用しない（latentのみ使用）
+ # これはエラーを避けるための一時的な対策
+ if use_reference_image and reference_encoder_output is not None:
+ # 参照画像のCLIP特徴は直接使用せず、latentでのみ反映
+ # これによりrotary embedding関連のエラーを回避
+ pass
+
+ # PRの実装に従い、one_frame_inferenceモードではsample_num_framesをサンプリングに使用
+ if sample_num_frames == 1:
+ # latent_indicesと同様に、clean_latent_indicesも調整する必要がある
+ # 参照画像を使用しない場合のみ、最初の1要素に制限
+ if clean_latent_indices.shape[1] > 1 and not use_reference_image:
+ clean_latent_indices = clean_latent_indices[:, 0:1] # 入力画像（最初の1要素）のみ
+ # 参照画像使用時は両方のインデックスを保持（何もしない）
+
+ # clean_latentsも調整（最後の1フレームのみ）
+ # ただし、kisekaeichi機能の場合は、参照画像も保持する必要がある
+ # clean_latentsの調整 - 複数フレームがある場合の処理
+ if clean_latents.shape[2] > 1 and not use_reference_image:
+ # 参照画像を使用しない場合のみ、最初の1フレームに制限
+ clean_latents = clean_latents[:, :, 0:1] # 入力画像（最初の1フレーム）のみ
+
+ # 参照画像使用時は、両方のフレームを保持するため何もしない
+
+ # clean_latentsの処理
+ if use_reference_image:
+ # PRのkisekaeichi実装オプション
+ # target_indexとhistory_indexの処理は既に上で実行済み
+
+ # オプション処理
+ if not use_clean_latents_2x: # PRの"no_2x"オプション
+ clean_latents_2x = None
+ clean_latent_2x_indices = None
+
+ if not use_clean_latents_4x: # PRの"no_4x"オプション
+ clean_latents_4x = None
+ clean_latent_4x_indices = None
+
+ # clean_latents_2xとclean_latents_4xも必要に応じて調整
+ if clean_latents_2x is not None and clean_latents_2x.shape[2] > 1:
+ clean_latents_2x = clean_latents_2x[:, :, -1:] # 最後の1フレームのみ
+
+ if clean_latents_4x is not None and clean_latents_4x.shape[2] > 1:
+ clean_latents_4x = clean_latents_4x[:, :, -1:] # 最後の1フレームのみ
+
+ # clean_latent_2x_indicesとclean_latent_4x_indicesも調整
+ if clean_latent_2x_indices is not None and clean_latent_2x_indices.shape[1] > 1:
+ clean_latent_2x_indices = clean_latent_2x_indices[:, -1:]
+
+ if clean_latent_4x_indices is not None and clean_latent_4x_indices.shape[1] > 1:
+ clean_latent_4x_indices = clean_latent_4x_indices[:, -1:]
+
+ # 最も重要な問題：widthとheightが間違っている可能性
+ # エラーログから、widthが60、heightが104になっているのが問題
+ # これらはlatentサイズであり、実際の画像サイズではない
+ print(translate("実際の画像サイズを再確認"))
+ print(translate("入力画像のサイズ: {0}").format(input_image_np.shape))
+
+ # find_nearest_bucketの結果が間違っている可能性
+ # 入力画像のサイズから正しい値を計算
+ if input_image_np.shape[0] == 832 and input_image_np.shape[1] == 480:
+ # 実際の画像サイズを使用
+ actual_width = 480
+ actual_height = 832
+ print(translate("実際の画像サイズを使用: width={0}, height={1}").format(actual_width, actual_height))
+ else:
+ # find_nearest_bucketの結果を使用
+ actual_width = width
+ actual_height = height
+
+ generated_latents = sample_hunyuan(
+ transformer=transformer,
+ sampler='unipc',
+ width=actual_width,
+ height=actual_height,
+ frames=sample_num_frames,
+ real_guidance_scale=cfg,
+ distilled_guidance_scale=gs,
+ guidance_rescale=rs,
+ 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=gpu,
+ dtype=torch.bfloat16,
+ 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,
+ )
+
+ # コールバックからの戻り値をチェック（コールバック関数が特殊な値を返した場合）
+ if isinstance(generated_latents, dict) and generated_latents.get('user_interrupt'):
+ # ユーザーが中断したことを検出したが、メッセージは出さない（既に表示済み）
+ # 現在のバッチは完了させる（KeyboardInterruptは使わない）
+ print(translate("バッチ内処理を完了します"))
+ else:
+ print(translate("生成は正常に完了しました"))
+
+ # サンプリング直後のメモリクリーンアップ（重要）
+ # transformerの中間状態を明示的にクリア（KVキャッシュに相当）
+ if hasattr(transformer, 'enable_teacache'):
+ transformer.enable_teacache = False
+ print(translate("transformerのキャッシュをクリア"))
+
+ # 不要なモデル変数を積極的に解放
+ torch.cuda.empty_cache()
+
+ except KeyboardInterrupt:
+ print(translate("キーボード割り込みを検出しました - 安全に停止します"))
+ # リソースのクリーンアップ
+ del llama_vec, llama_vec_n, llama_attention_mask, llama_attention_mask_n
+ del clip_l_pooler, clip_l_pooler_n
+ try:
+ # モデルをCPUに移動（可能な場合のみ）
+ if 'transformer' in locals() and transformer is not None:
+ if hasattr(transformer, 'cpu'):
+ transformer.cpu()
+ # GPUキャッシュをクリア
+ torch.cuda.empty_cache()
+ except Exception as cleanup_e:
+ print(translate("停止時のクリーンアップでエラー: {0}").format(cleanup_e))
+ # バッチ停止フラグを設定
+ batch_stopped = True
+ return None
+
+ except RuntimeError as e:
+ error_msg = str(e)
+ if "size of tensor" in error_msg:
+ print(translate("テンソルサイズの不一致エラーが発生しました: {0}").format(error_msg))
+ print(translate("開発者に報告してください。"))
+ raise e
+ else:
+ # その他のランタイムエラーはそのまま投げる
+ raise e
+
+ total_generated_latent_frames += int(generated_latents.shape[2])
+ history_latents = torch.cat([generated_latents.to(history_latents), history_latents], dim=2)
+
+ # 生成完了後のメモリ最適化 - 軽量な処理に変更
+ if not high_vram:
+ # transformerのメモリを軽量に解放（辞書リセットなし）
+ print(translate("生成完了 - transformerをアンロード中..."))
+
+ # 元の方法に戻す - 軽量なオフロードで速度とメモリのバランスを取る
+ offload_model_from_device_for_memory_preservation(transformer, target_device=gpu, preserved_memory_gb=8)
+
+ # アンロード後のメモリ状態をログ
+ free_mem_gb_after_unload = get_cuda_free_memory_gb(gpu)
+ print(translate("transformerアンロード後の��きVRAM {0} GB").format(free_mem_gb_after_unload))
+
+ # VAEをデコード用にロード（VAEが解放されていた場合は再ロード）
+ if vae is None:
+ print(translate("VAEモデルを再ロードします..."))
+ try:
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=torch.float16).cpu()
+ setup_vae_if_loaded() # VAEの設定を適用
+ print(translate("VAEモデルの再ロードが完了しました"))
+ except Exception as e:
+ print(translate("VAEモデルの再ロードに失敗しました: {0}").format(e))
+ traceback.print_exc()
+ print(translate("5秒間待機後に再試行します..."))
+ time.sleep(5)
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=torch.float16).cpu()
+ setup_vae_if_loaded() # VAEの設定を適用
+
+ print(translate("VAEをGPUにロード中..."))
+ load_model_as_complete(vae, target_device=gpu)
+
+ # ロード後のメモリ状態をログ
+ free_mem_gb_after_vae = get_cuda_free_memory_gb(gpu)
+ print(translate("VAEロード後の空きVRAM {0} GB").format(free_mem_gb_after_vae))
+
+ # 追加のメモリクリーンアップ
+ torch.cuda.empty_cache()
+
+ # 実際に使用するラテントを抽出
+ real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :]
+
+ # 使用していないテンソルを早めに解放
+ del history_latents
+ torch.cuda.empty_cache()
+
+ # 1フレームモードではVAEデコードを行い、画像を直接保存
+ try:
+ # VAEデコード処理前にメモリを確認
+ free_mem_before_decode = get_cuda_free_memory_gb(gpu)
+
+ # VAEが解放されていた場合は再ロード
+ if vae is None:
+ try:
+ vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=torch.float16).cpu()
+ setup_vae_if_loaded() # VAEの設定を適用
+ # VAEをGPUに移動
+ load_model_as_complete(vae, target_device=gpu)
+ print(translate("VAEモデルの再ロードが完了しました"))
+ except Exception as e:
+ print(translate("VAEモデルの再ロードに失敗しました: {0}").format(e))
+ traceback.print_exc()
+ raise e
+
+ # VAEデコード処理
+ with torch.no_grad(): # 明示的にno_gradコンテキストを使用
+ # ラテントをCPUではなくGPUに置いて効率的に処理
+ real_history_latents_gpu = real_history_latents.to(gpu)
+ decoded_image = vae_decode(real_history_latents_gpu, vae).cpu()
+
+ # 不要なGPU上のラテントをすぐに解放
+ del real_history_latents_gpu
+ torch.cuda.empty_cache()
+
+ # デコード後にVAEをCPUに移動してメモリを解放
+ if not high_vram and vae is not None:
+ vae.to('cpu')
+ torch.cuda.empty_cache()
+
+ # デコード後のメモリを確認
+ free_mem_after_decode = get_cuda_free_memory_gb(gpu)
+
+ # 単一フレームを抽出
+ frame = decoded_image[0, :, 0, :, :]
+ frame = torch.clamp(frame, -1., 1.) * 127.5 + 127.5
+ frame = frame.detach().cpu().to(torch.uint8)
+ frame = einops.rearrange(frame, 'c h w -> h w c').numpy()
+
+ # デコード結果を解放
+ del decoded_image
+ del real_history_latents
+ torch.cuda.empty_cache()
+
+ # メタデータを設定
+ metadata = {
+ PROMPT_KEY: prompt,
+ SEED_KEY: seed # intとして保存
+ }
+
+ # 画像として保存（メタデータ埋め込み）
+ from PIL import Image
+ output_filename = os.path.join(outputs_folder, f'{job_id}_oneframe.png')
+ pil_img = Image.fromarray(frame)
+ pil_img.save(output_filename) # 一度保存
+
+ # メタデータを埋め込み
+ try:
+ # 関数は2つの引数しか取らないので修正
+ embed_metadata_to_png(output_filename, metadata)
+ print(translate("画像メタデータを埋め込みました"))
+ except Exception as e:
+ print(translate("メタデータ埋め込みエラー: {0}").format(e))
+
+ print(translate("1フレーム画像を保存しました: {0}").format(output_filename))
+
+ # MP4保存はスキップして、画像ファイルパスを返す
+ stream.output_queue.push(('file', output_filename))
+
+ except Exception as e:
+ print(translate("1フレームの画像保存中にエラーが発生しました: {0}").format(e))
+ traceback.print_exc()
+
+ # エラー発生時のメモリ解放を試みる
+ if 'real_history_latents_gpu' in locals():
+ del real_history_latents_gpu
+ if 'real_history_latents' in locals():
+ del real_history_latents
+ if 'decoded_image' in locals():
+ del decoded_image
+ torch.cuda.empty_cache()
+
+ break # 1フレーム生成は1回のみ
+
+ except Exception as e:
+ print(translate("処理中にエラーが発生しました: {0}").format(e))
+ traceback.print_exc()
+
+ # エラー時の詳細なメモリクリーンアップ
+ try:
+ if not high_vram:
+ print(translate("エラー発生時のメモリクリーンアップを実行..."))
+
+ # 効率的なクリーンアップのために、重いモデルから順にアンロード
+ models_to_unload = [
+ ('transformer', transformer),
+ ('vae', vae),
+ ('image_encoder', image_encoder),
+ ('text_encoder', text_encoder),
+ ('text_encoder_2', text_encoder_2)
+ ]
+
+ # 各モデルを個別にアンロードして解放
+ for model_name, model in models_to_unload:
+ if model is not None:
+ try:
+ print(translate("{0}をアンロード中...").format(model_name))
+ # モデルをCPUに移動
+ if hasattr(model, 'to'):
+ model.to('cpu')
+ # 参照を明示的に削除
+ if model_name == 'transformer':
+ transformer = None
+ elif model_name == 'vae':
+ vae = None
+ elif model_name == 'image_encoder':
+ image_encoder = None
+ elif model_name == 'text_encoder':
+ text_encoder = None
+ elif model_name == 'text_encoder_2':
+ text_encoder_2 = None
+ # 各モデル解放後にすぐメモリ解放
+ torch.cuda.empty_cache()
+ except Exception as unload_error:
+ print(translate("{0}のアンロード中にエラー: {1}").format(model_name, unload_error))
+
+ # 一括アンロード - endframe_ichiと同じアプローチでモデルを明示的に解放
+ if transformer is not None:
+ # まずtransformer_managerの状態をリセット - これが重要
+ transformer_manager.current_state['is_loaded'] = False
+ # FP8最適化モードの有無に関わらず常にCPUに移動
+ transformer.to('cpu')
+ print(translate("transformerをCPUに移動しました"))
+
+ # endframe_ichi.pyと同様に明示的にすべてのモデルを一括アンロード
+ # モデルを直接リストで渡す（引数展開ではなく）
+ unload_complete_models(
+ text_encoder, text_encoder_2, image_encoder, vae, transformer
+ )
+ print(translate("すべてのモデルをアンロードしました"))
+
+ # 明示的なガベージコレクション（複数回）
+ import gc
+ print(translate("ガベージコレクション実行中..."))
+ gc.collect()
+ torch.cuda.empty_cache()
+ gc.collect()
+ torch.cuda.empty_cache()
+
+ # メモリ状態を報告
+ free_mem_gb = get_cuda_free_memory_gb(gpu)
+ print(translate("クリーンアップ後の空きVRAM {0} GB").format(free_mem_gb))
+
+ # 追加の変数クリーンアップ
+ for var_name in ['start_latent', 'decoded_image', 'history_latents', 'real_history_latents',
+ 'real_history_latents_gpu', 'generated_latents', 'input_image_pt', 'input_image_gpu']:
+ if var_name in locals():
+ try:
+ exec(f"del {var_name}")
+ print(translate("変数 {0} を解放しました").format(var_name))
+ except:
+ pass
+ except Exception as cleanup_error:
+ print(translate("メモリクリーンアップ中にエラー: {0}").format(cleanup_error))
+
+ # 処理完了を通知（個別バッチの完了）
+ print(translate("処理が完了しました"))
+
+ # worker関数内では効果音を鳴らさない（バッチ処理全体の完了時のみ鳴らす）
+
+ stream.output_queue.push(('end', None))
+ return
+
+def handle_open_folder_btn(folder_name):
+ """フォルダ名を保存し、そのフォルダを開く - endframe_ichiと同じ実装"""
+ if not folder_name or not folder_name.strip():
+ folder_name = "outputs"
+
+ # フォルダパスを取得
+ folder_path = get_output_folder_path(folder_name)
+
+ # 設定を更新して保存
+ settings = load_settings()
+ old_folder_name = settings.get('output_folder')
+
+ if old_folder_name != folder_name:
+ settings['output_folder'] = folder_name
+ save_result = save_settings(settings)
+ if save_result:
+ # グローバル変数も更新
+ global output_folder_name, outputs_folder
+ output_folder_name = folder_name
+ outputs_folder = folder_path
+ print(translate("出力フォルダ設定を保存しました: {folder_name}").format(folder_name=folder_name))
+
+ # フォルダを開く
+ open_output_folder(folder_path)
+
+ # 出力ディレクトリ入力欄とパス表示を更新
+ return gr.update(value=folder_name), gr.update(value=folder_path)
+
+def update_from_image_metadata(image_path, should_copy):
+ """画像からメタデータを抽出してプロンプトとシードを更新する関数
+
+ Args:
+ image_path: 画像ファイルパス
+ should_copy: メタデータを複写するかどうかの指定
+
+ Returns:
+ tuple: (プロンプト更新データ, シード値更新データ)
+ """
+ if not should_copy or image_path is None:
+ return gr.update(), gr.update()
+
+ try:
+ # ファイルパスからメタデータを抽出
+ metadata = extract_metadata_from_png(image_path)
+
+ if not metadata:
+ print(translate("画像にメタデータが含まれていません"))
+ return gr.update(), gr.update()
+
+ # プロンプトとSEEDをUIに反映
+ prompt_update = gr.update()
+ seed_update = gr.update()
+
+ if PROMPT_KEY in metadata and metadata[PROMPT_KEY]:
+ prompt_update = gr.update(value=metadata[PROMPT_KEY])
+ print(translate("プロンプトを画像から取得: {0}").format(metadata[PROMPT_KEY]))
+
+ if SEED_KEY in metadata and metadata[SEED_KEY]:
+ # SEED値を整数に変換
+ try:
+ seed_value = int(metadata[SEED_KEY])
+ seed_update = gr.update(value=seed_value)
+ print(translate("シード値を画像から取得: {0}").format(seed_value))
+ except ValueError:
+ print(translate("シード値の変換に失敗しました: {0}").format(metadata[SEED_KEY]))
+
+ return prompt_update, seed_update
+
+ except Exception as e:
+ print(translate("メタデータ抽出エラー: {0}").format(e))
+ return gr.update(), gr.update()
+
+def check_metadata_on_checkbox_change(should_copy, image_path):
+ """チェックボックスの状態が変更された時に画像からメタデータを抽出する関数"""
+ return update_from_image_metadata(image_path, should_copy)
+
+def process(input_image, prompt, n_prompt, seed, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache,
+ lora_files, lora_files2, lora_scales_text, use_lora, fp8_optimization, resolution, output_directory=None,
+ batch_count=1, use_random_seed=False, latent_window_size=9, latent_index=0,
+ use_clean_latents_2x=True, use_clean_latents_4x=True, use_clean_latents_post=True,
+ lora_mode=None, lora_dropdown1=None, lora_dropdown2=None, lora_dropdown3=None, lora_files3=None,
+ use_rope_batch=False, use_queue=False, prompt_queue_file=None,
+ # Kisekaeichi 関連のパラメータ
+ use_reference_image=False, reference_image=None,
+ target_index=1, history_index=13, input_mask=None, reference_mask=None,
+ save_settings_on_start=False, alarm_on_completion=True):
+ global stream
+ global batch_stopped, user_abort, user_abort_notified
+ global queue_enabled, queue_type, prompt_queue_file_path, image_queue_files
+
+ # 新たな処理開始時にグローバルフラグをリセット
+ user_abort = False
+ user_abort_notified = False
+
+ # プロセス開始時にバッチ中断フラグをリセット
+ batch_stopped = False
+
+ # バッチ処理回数を確認し、詳細を出力
+ # 型チェックしてから変換（数値でない場合はデフォルト値の1を使用）
+ try:
+ batch_count_val = int(batch_count)
+ batch_count = max(1, min(batch_count_val, 100)) # 1〜100の間に制限
+ except (ValueError, TypeError):
+ print(translate("バッチ処理回数が無効です。デフォルト値の1を使用します: {0}").format(batch_count))
+ batch_count = 1 # デフォルト値
+
+ # キュー関連の設定を保存
+ queue_enabled = bool(use_queue) # UIからの値をブール型に変換
+
+ # プロンプトキューファイルが指定されている場合はパスを保存
+ if queue_enabled and prompt_queue_file is not None:
+ if hasattr(prompt_queue_file, 'name') and os.path.exists(prompt_queue_file.name):
+ prompt_queue_file_path = prompt_queue_file.name
+ queue_type = "prompt" # キュータイプをプロンプトに設定
+ print(translate("プロンプトキューファイルパスを設定: {0}").format(prompt_queue_file_path))
+
+ # プロンプトファイルの内容を確認し、行数を出力
+ try:
+ with open(prompt_queue_file_path, 'r', encoding='utf-8') as f:
+ prompt_lines = [line.strip() for line in f.readlines() if line.strip()]
+ prompt_count = len(prompt_lines)
+ if prompt_count > 0:
+ if batch_count > prompt_count:
+ print(translate("バッチ処理回数: {0}回（プロンプトキュー行を優先: {1}行、残りは共通プロンプトで実施）").format(batch_count, prompt_count))
+ else:
+ print(translate("バッチ処理回数: {0}回（プロンプトキュー行を優先: {1}行）").format(batch_count, prompt_count))
+ else:
+ print(translate("バッチ処理回数: {0}回").format(batch_count))
+ except Exception as e:
+ print(translate("プロンプトファイル読み込みエラー: {0}").format(str(e)))
+ print(translate("バッチ処理回数: {0}回").format(batch_count))
+ else:
+ print(translate("警告: プロンプトキューファイルが存在しません: {0}").format(
+ prompt_queue_file.name if hasattr(prompt_queue_file, 'name') else "不明なファイル"))
+ print(translate("バッチ処理回数: {0}回").format(batch_count))
+ else:
+ print(translate("バッチ処理回数: {0}回").format(batch_count))
+
+ # キュー機能の設定を更新
+ queue_ui_value = bool(use_queue)
+ queue_enabled = queue_ui_value
+
+ # プロンプトキューの処理
+ if queue_enabled and prompt_queue_file is not None:
+ queue_type = "prompt" # キュータイプをプロンプトに設定
+
+ # アップロードされたファイルパスを取得
+ if hasattr(prompt_queue_file, 'name') and os.path.exists(prompt_queue_file.name):
+ prompt_queue_file_path = prompt_queue_file.name
+ print(translate("プロンプトキューファイルパスを設定: {0}").format(prompt_queue_file_path))
+
+ # ファイルの内容を確認
+ try:
+ with open(prompt_queue_file_path, 'r', encoding='utf-8') as f:
+ lines = [line.strip() for line in f.readlines() if line.strip()]
+ queue_prompts_count = len(lines)
+ print(translate("有効なプロンプト行数: {0}").format(queue_prompts_count))
+
+ if queue_prompts_count > 0:
+ # サンプルとして最初の数行を表示
+ sample_lines = lines[:min(3, queue_prompts_count)]
+ print(translate("プロンプトサンプル: {0}").format(sample_lines))
+
+ # バッチ数をプロンプト数に合わせる
+ if queue_prompts_count > batch_count:
+ print(translate("プロンプト数に合わせてバッチ数を自動調整: {0} → {1}").format(
+ batch_count, queue_prompts_count))
+ batch_count = queue_prompts_count
+ except Exception as e:
+ print(translate("プロンプトキューファイル読み込みエラー: {0}").format(str(e)))
+ else:
+ print(translate("プロンプトキューファイルが存在しないか無効です"))
+
+ # イメージキューの処理
+ elif queue_enabled and queue_ui_value and use_queue:
+ # イメージキューが選択された場合
+ queue_type = "image" # キュータイプをイメージに設定
+
+ # 入力フォルダから画像ファイルリストを取得
+ get_image_queue_files()
+
+ # イメージキューの数を確認
+ image_queue_count = len(image_queue_files)
+ print(translate("イメージキュー: {0}個の画像ファイルを読み込みました").format(image_queue_count))
+
+ if image_queue_count > 0:
+ # 入力画像を使う1回 + 画像ファイル分のバッチ数
+ total_needed_batches = 1 + image_queue_count
+
+ # 設定されたバッチ数より必要数が多い場合は調整
+ if total_needed_batches > batch_count:
+ print(translate("画像キュー数+1に合わせてバッチ数を自動調整: {0} → {1}").format(
+ batch_count, total_needed_batches))
+ batch_count = total_needed_batches
+
+ # 出力フォルダの設定
+ global outputs_folder
+ global output_folder_name
+ if output_directory and output_directory.strip():
+ # 出力フォルダパスを取得
+ outputs_folder = get_output_folder_path(output_directory)
+ print(translate("出力フォルダを設定: {0}").format(outputs_folder))
+
+ # フォルダ名が現在の設定と異なる場合は設定ファイルを更新
+ if output_directory != output_folder_name:
+ settings = load_settings()
+ settings['output_folder'] = output_directory
+ if save_settings(settings):
+ output_folder_name = output_directory
+ print(translate("出力フォルダ設定を保存しました: {0}").format(output_directory))
+ else:
+ # デフォルト設定を使用
+ outputs_folder = get_output_folder_path(output_folder_name)
+ print(translate("デフォルト出力フォルダを使用: {0}").format(outputs_folder))
+
+ # フォルダが存在しない場合は作成
+ os.makedirs(outputs_folder, exist_ok=True)
+
+ # 出力ディレクトリを設定
+ output_dir = outputs_folder
+
+ # バッチ処理のパラメータチェック
+ batch_count = max(1, min(int(batch_count), 100)) # 1〜100の間に制限
+ print(translate("バッチ処理回数: {0}回").format(batch_count))
+
+ # 入力画像チェック - 厳格なチェックを避け、エラーを出力するだけに変更
+ if input_image is None:
+ print(translate("入力画像が指定されていません。デフォルトの画像を生成します。"))
+ # 空の入力画像を生成
+ # ここではNoneのままとし、実際のworker関数内でNoneの場合に対応する
+
+ yield gr.skip(), None, '', '', gr.update(interactive=False), gr.update(interactive=True)
+
+ # バッチ処理用の変数 - 各フラグをリセット
+ batch_stopped = False
+ user_abort = False
+ user_abort_notified = False
+ original_seed = seed if seed else (random.randint(0, 2**32 - 1) if use_random_seed else 31337)
+
+ # 設定の自動保存処理（最初のバッチ開始時のみ）
+ if save_settings_on_start and batch_count > 0:
+ print(translate("=== 現在の設定を自動保存します ==="))
+ # 現在のUIの値を収集してアプリケーション設定として保存
+ current_settings = {
+ 'resolution': resolution,
+ 'steps': steps,
+ 'cfg': cfg,
+ 'use_teacache': use_teacache,
+ 'gpu_memory_preservation': gpu_memory_preservation,
+ 'gs': gs,
+ 'latent_window_size': latent_window_size,
+ 'latent_index': latent_index,
+ 'use_clean_latents_2x': use_clean_latents_2x,
+ 'use_clean_latents_4x': use_clean_latents_4x,
+ 'use_clean_latents_post': use_clean_latents_post,
+ 'target_index': target_index,
+ 'history_index': history_index,
+ 'save_settings_on_start': save_settings_on_start,
+ 'alarm_on_completion': alarm_on_completion
+ }
+
+ # 設定を保存
+ if save_app_settings_oichi(current_settings):
+ print(translate("アプリケーション設定を保存しました"))
+ else:
+ print(translate("アプリケーション設定の保存に失敗しました"))
+
+ # バッチ処理ループ
+ # バッチ処理のサマリーを出力
+ if queue_enabled:
+ if queue_type == "prompt" and prompt_queue_file_path is not None:
+ # プロンプトキュー情報をログに出力
+ try:
+ with open(prompt_queue_file_path, 'r', encoding='utf-8') as f:
+ queue_lines = [line.strip() for line in f.readlines() if line.strip()]
+ queue_lines_count = len(queue_lines)
+ print(translate("バッチ処理情報: 合計{0}回").format(batch_count))
+ print(translate("プロンプトキュー: 有効, プロンプト行数={0}行").format(queue_lines_count))
+
+ # 各プロンプトの概要を出力
+ print(translate("プロンプトキュー内容:"))
+ for i in range(min(batch_count, queue_lines_count)):
+ prompt_preview = queue_lines[i][:50] + "..." if len(queue_lines[i]) > 50 else queue_lines[i]
+ print(translate(" └ バッチ{0}: {1}").format(i+1, prompt_preview))
+ except:
+ pass
+ elif queue_type == "image" and len(image_queue_files) > 0:
+ # イメージキュー情報をログに出力
+ print(translate("バッチ処理情報: 合計{0}回").format(batch_count))
+ print(translate("イメージキュー: 有効, 画像ファイル数={0}個").format(len(image_queue_files)))
+
+ # 各画像ファイルの概要を出力
+ print(translate("イメージキュー内容:"))
+ print(translate(" └ バッチ1: 入力画像 (最初のバッチは常に入力画像を使用)"))
+ for i, img_path in enumerate(image_queue_files[:min(batch_count-1, len(image_queue_files))]):
+ img_name = os.path.basename(img_path)
+ print(translate(" └ バッチ{0}: {1}").format(i+2, img_name))
+ else:
+ print(translate("バッチ処理情報: 合計{0}回").format(batch_count))
+ print(translate("キュー機能: 無効"))
+
+ for batch_index in range(batch_count):
+ # 停止フラグが設定されている場合は全バッチ処理を中止
+ if batch_stopped:
+ print(translate("バッチ処理がユーザーによって中止されました"))
+ yield (
+ gr.skip(),
+ gr.update(visible=False),
+ translate("バッチ処理が中止されました。"),
+ '',
+ gr.update(interactive=True),
+ gr.update(interactive=False, value=translate("End Generation"))
+ )
+ break
+
+ # バッチ情報をログ出力
+ if batch_count > 1:
+ batch_info = translate("バッチ処理: {0}/{1}").format(batch_index + 1, batch_count)
+ print(f"{batch_info}")
+ # UIにもバッチ情報を表示
+ yield gr.skip(), gr.update(visible=False), batch_info, "", gr.update(interactive=False), gr.update(interactive=True)
+
+ # 今回処理用のプロンプトとイメージを取得（キュー機能対応）
+ current_prompt = prompt
+ current_image = input_image
+
+ # キュー機能の処理
+ if queue_enabled:
+ if queue_type == "prompt" and prompt_queue_file_path is not None:
+ # プロンプトキューの処理
+ if os.path.exists(prompt_queue_file_path):
+ try:
+ with open(prompt_queue_file_path, 'r', encoding='utf-8') as f:
+ lines = [line.strip() for line in f.readlines() if line.strip()]
+ if batch_index < len(lines):
+ # プロンプトキューからプロンプトを取得
+ current_prompt = lines[batch_index]
+ print(translate("プロンプトキュー実行中: バッチ {0}/{1}").format(batch_index+1, batch_count))
+ print(translate(" └ プロンプト: 「{0}...」").format(current_prompt[:50]))
+ else:
+ print(translate("プロンプトキュー実行中: バッチ {0}/{1} はプロンプト行数を超えているため元のプロンプトを使用").format(batch_index+1, batch_count))
+ except Exception as e:
+ print(translate("プロンプトキューファイル読み込みエラー: {0}").format(str(e)))
+
+ elif queue_type == "image" and len(image_queue_files) > 0:
+ # イメージキューの処理
+ # 最初のバッチは入力画像を使用
+ if batch_index == 0:
+ print(translate("イメージキュー実行中: バッチ {0}/{1} は入力画像を使用").format(batch_index+1, batch_count))
+ elif batch_index > 0:
+ # 2回目以降はイメージキューの画像を順番に使用
+ image_index = batch_index - 1 # 0回目（入力画像）の分を引く
+
+ if image_index < len(image_queue_files):
+ current_image = image_queue_files[image_index]
+ image_filename = os.path.basename(current_image)
+ print(translate("イメージキュー実行中: バッチ {0}/{1} の画像「{2}」").format(batch_index+1, batch_count, image_filename))
+ print(translate(" └ 画像ファイルパス: {0}").format(current_image))
+
+ # 同名のテキストファイルがあるか確認し、あれば内容をプロンプトとして使用
+ img_basename = os.path.splitext(current_image)[0]
+ txt_path = f"{img_basename}.txt"
+ if os.path.exists(txt_path):
+ try:
+ with open(txt_path, 'r', encoding='utf-8') as f:
+ custom_prompt = f.read().strip()
+ if custom_prompt:
+ print(translate("イメージキュー: 画像「{0}」用のテキストファイルを読み込みました").format(image_filename))
+ print(translate("カスタムプロンプト: {0}").format(custom_prompt[:50] + "..." if len(custom_prompt) > 50 else custom_prompt))
+ # カスタムプロンプトを設定（current_promptを上書き）
+ current_prompt = custom_prompt
+ except Exception as e:
+ print(translate("イメージキュー: テキストファイル読み込みエラー: {0}").format(e))
+ else:
+ # 画像数が足りない場合は入力画像に戻る
+ print(translate("イメージキュー実行中: バッチ {0}/{1} は画像数を超えているため入力画像を使用").format(batch_index+1, batch_count))
+
+ # RoPE値バッチ処理の場合はRoPE値をインクリメント、それ以外は通常のシードインクリメント
+ current_seed = original_seed
+ current_latent_window_size = latent_window_size
+
+ if use_rope_batch:
+ # RoPE値をインクリメント（最大64まで）
+ new_rope_value = latent_window_size + batch_index
+
+ # RoPE値が64を超えたら処理を終了
+ if new_rope_value > 64:
+ print(translate("RoPE値が上限（64）に達したため、処理を終了します"))
+ break
+
+ current_latent_window_size = new_rope_value
+ print(translate("RoPE値: {0}").format(current_latent_window_size))
+ else:
+ # 通常のバッチ処理：シード値をインクリメント
+ current_seed = original_seed + batch_index
+ if batch_count > 1:
+ print(translate("初期シード値: {0}").format(current_seed))
+
+ if batch_stopped:
+ break
+
+ try:
+ # 新しいストリームを作成
+ stream = AsyncStream()
+
+ # バッチインデックスをジョブIDに含める
+ batch_suffix = f"{batch_index}" if batch_index > 0 else ""
+
+ # 中断フラグの再確認
+ if batch_stopped:
+ break
+
+ # ワーカー実行 - 詳細設定パラメータを含む（キュー機能対応）
+ async_run(worker, current_image, current_prompt, n_prompt, current_seed, steps, cfg, gs, rs,
+ gpu_memory_preservation, use_teacache, lora_files, lora_files2, lora_scales_text,
+ output_dir, use_lora, fp8_optimization, resolution,
+ current_latent_window_size, latent_index, use_clean_latents_2x, use_clean_latents_4x, use_clean_latents_post,
+ lora_mode, lora_dropdown1, lora_dropdown2, lora_dropdown3, lora_files3,
+ batch_index, use_queue, prompt_queue_file,
+ # Kisekaeichi関連パラメータを追加
+ use_reference_image, reference_image,
+ target_index, history_index, input_mask, reference_mask)
+ except Exception as e:
+ import traceback
+
+ output_filename = None
+
+ # ジョブ完了まで監視
+ try:
+ # ストリーム待機開始
+ while True:
+ try:
+ flag, data = stream.output_queue.next()
+
+ if flag == 'file':
+ output_filename = data
+ yield (
+ output_filename if output_filename is not None else gr.skip(),
+ gr.update(),
+ gr.update(),
+ gr.update(),
+ gr.update(interactive=False),
+ gr.update(interactive=True),
+ )
+
+ if flag == 'progress':
+ preview, desc, html = data
+ yield gr.skip(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
+
+ if flag == 'end':
+ # endフラグを受信
+ # バッチ処理中は最後の画像のみを表示
+ if batch_index == batch_count - 1 or batch_stopped: # 最後のバッチまたは中断された場合
+ completion_message = ""
+ if batch_stopped:
+ completion_message = translate("バッチ処理が中断されました（{0}/{1}）").format(batch_index + 1, batch_count)
+ else:
+ completion_message = translate("バッチ処理が完了しました（{0}/{1}）").format(batch_count, batch_count)
+
+ # 完了メッセージでUIを更新
+ yield (
+ output_filename if output_filename is not None else gr.skip(),
+ gr.update(visible=False),
+ completion_message,
+ '',
+ gr.update(interactive=True, value=translate("Start Generation")),
+ gr.update(interactive=False, value=translate("End Generation")),
+ )
+ break
+
+ # ユーザーが中断した場合
+ if stream.input_queue.top() == 'end' or batch_stopped:
+ batch_stopped = True
+ # 処理ループ内での中断検出
+ print(translate("バッチ処理が中断されました（{0}/{1}）").format(batch_index + 1, batch_count))
+ # endframe_ichiと同様のシンプルな実装に戻す
+ yield (
+ output_filename if output_filename is not None else gr.skip(),
+ gr.update(visible=False),
+ translate("バッチ処理が中断されました"),
+ '',
+ gr.update(interactive=True),
+ gr.update(interactive=False, value=translate("End Generation")),
+ )
+ return
+
+ except Exception as e:
+ import traceback
+ # エラー後はループを抜ける
+ break
+
+ except KeyboardInterrupt:
+ # 明示的なリソースクリーンアップ
+ try:
+ # グローバルモデル変数のクリーンアップ
+ global transformer, text_encoder, text_encoder_2, vae, image_encoder
+ # 各モデルが存在する場合にCPUに移動
+ if transformer is not None and hasattr(transformer, 'cpu'):
+ try:
+ transformer.cpu()
+ except: pass
+ if text_encoder is not None and hasattr(text_encoder, 'cpu'):
+ try:
+ text_encoder.cpu()
+ except: pass
+ if text_encoder_2 is not None and hasattr(text_encoder_2, 'cpu'):
+ try:
+ text_encoder_2.cpu()
+ except: pass
+ if vae is not None and hasattr(vae, 'cpu'):
+ try:
+ vae.cpu()
+ except: pass
+ if image_encoder is not None and hasattr(image_encoder, 'cpu'):
+ try:
+ image_encoder.cpu()
+ except: pass
+
+ # GPUキャッシュの完全クリア
+ torch.cuda.empty_cache()
+ except Exception as cleanup_e:
+ # クリーンアップ中のエラーを無視
+ pass
+
+ # UIをリセット
+ yield None, gr.update(visible=False), translate("キーボード割り込みにより処理が中断されました"), '', gr.update(interactive=True, value=translate("Start Generation")), gr.update(interactive=False, value=translate("End Generation"))
+ return
+ except Exception as e:
+ import traceback
+ # UIをリセット
+ yield None, gr.update(visible=False), translate("エラーにより処理が中断されました"), '', gr.update(interactive=True, value=translate("Start Generation")), gr.update(interactive=False, value=translate("End Generation"))
+ return
+
+ # すべてのバッ��処理が正常に完了した場合と中断された場合で表示メッセージを分ける
+ if batch_stopped:
+ if user_abort:
+ print(translate("ユーザーの指示により処理を停止しました"))
+ else:
+ print(translate("バッチ処理が中断されました"))
+ else:
+ print(translate("全てのバッチ処理が完了しました"))
+
+ # バッチ処理終了後は必ずフラグをリセット
+ batch_stopped = False
+ user_abort = False
+ user_abort_notified = False
+
+ # 処理完了時の効果音（アラーム設定が有効な場合のみ）
+ if HAS_WINSOUND and alarm_on_completion:
+ try:
+ # Windows環境では完了音を鳴らす
+ winsound.PlaySound("SystemAsterisk", winsound.SND_ALIAS)
+ print(translate("Windows完了通知音を再生しました"))
+ except Exception as e:
+ print(translate("完了通知音の再生に失敗しました: {0}").format(e))
+
+ # 処理状態に応じてメッセージを表示
+ if batch_stopped or user_abort:
+ print("-" * 50)
+ print(translate("【ユーザー中断】処理は正常に中断されました - ") + time.strftime("%Y-%m-%d %H:%M:%S"))
+ print("-" * 50)
+ else:
+ print("*" * 50)
+ print(translate("【全バッチ処理完了】プロセスが完了しました - ") + time.strftime("%Y-%m-%d %H:%M:%S"))
+ print("*" * 50)
+
+ return
+
+def end_process():
+ """生成終了ボタンが押された時の処理"""
+ global stream
+ global batch_stopped, user_abort, user_abort_notified
+
+ # 重複停止通知を防止するためのチェック
+ if not user_abort:
+ # 現在のバッチと次のバッチ処理を全て停止するフラグを設定
+ batch_stopped = True
+ user_abort = True
+
+ # 通知は一度だけ表示（ここで表示してフラグを設定）
+ print(translate("停止ボタンが押されました。開始前または現在の処理完了後に停止します..."))
+ user_abort_notified = True # 通知フラグを設定
+
+ # 現在実行中のバッチを停止
+ stream.input_queue.push('end')
+
+ # ボタンの名前を一時的に変更することでユーザーに停止処理が進行中であることを表示
+ return gr.update(value=translate("停止処理中..."))
+
+css = get_app_css() # eichi_utilsのスタイルを使用
+
+# アプリケーション起動時に保存された設定を読み込む
+saved_app_settings = load_app_settings_oichi()
+
+# 読み込んだ設定をログに出力
+if saved_app_settings:
+ pass
+else:
+ print(translate("保存された設定が見つかりません。デフォルト値を使用します"))
+
+block = gr.Blocks(css=css).queue()
+with block:
+ # eichiと同じ半透明度スタイルを使用
+ gr.HTML('FramePack-oichi
')
+
+ # 初期化時にtransformerの状態確認は行わない（必要時に遅延ロード）
+ # ここではロードをスキップして、ワーカー関数内で必要になったときにだけロードする
+
+ # Use Random Seedの初期値（先に定義して後で使う）
+ use_random_seed_default = True
+ seed_default = random.randint(0, 2**32 - 1) if use_random_seed_default else 31337
+
+ # eichiのプリセット管理関連のインポート
+ from eichi_utils.preset_manager import get_default_startup_prompt, load_presets, save_preset, delete_preset
+
+ with gr.Row():
+ with gr.Column(scale=1):
+ # 左カラム - eichiと同じ順番
+ # モードについての説明を画像枠の上に表示
+ gr.Markdown(translate("**「1フレーム推論」モードでは、1枚の新しい未来の画像を生成します。**"))
+
+ input_image = gr.Image(sources=['upload', 'clipboard'], type="filepath", label=translate("Image"), height=320)
+
+ # 解像度設定（画像の直下に）
+ resolution = gr.Dropdown(
+ label=translate("解像度"),
+ choices=[512, 640, 768, 960, 1080],
+ value=saved_app_settings.get("resolution", 640) if saved_app_settings else 640,
+ info=translate("出力画像の基準解像度。640推奨。960/1080は高負荷・高メモリ消費"),
+ elem_classes="saveable-setting"
+ )
+
+ # バッチ処理設定 - endframe_ichiと同じUIにする
+ with gr.Column(scale=1):
+ batch_count = gr.Slider(
+ label=translate("バッチ処理回数"),
+ minimum=1,
+ maximum=100,
+ value=1,
+ step=1,
+ info=translate("同じ設定で連続生成する回数。SEEDは各回で+1されます")
+ )
+
+ # RoPE値バッチ処理用のチェックボックス
+ use_rope_batch = gr.Checkbox(
+ label=translate("RoPE値バッチ処理を使用"),
+ value=False,
+ info=translate("チェックすると、SEEDではなくRoPE値を各バッチで+1していきます（64に達すると停止）")
+ )
+
+ # キュー機能設定 - endframe_ichiと同様の実装
+ with gr.Column(scale=1):
+ # キュー機能のグループ
+ with gr.Group():
+ gr.Markdown(f"### " + translate("キュー機能"))
+
+ # キュー機能の使用有無
+ use_queue = gr.Checkbox(
+ label=translate("キュー機能を使用"),
+ value=False,
+ info=translate("入力ディレクトリの画像または指定したプロンプトリストを使用して連続して画像を生成します")
+ )
+
+ # キュータイプの選択
+ queue_type_selector = gr.Radio(
+ choices=[translate("プロンプトキュー"), translate("イメージキュー")],
+ value=translate("プロンプトキュー"),
+ label=translate("キュータイプ"),
+ visible=False,
+ interactive=True
+ )
+
+ # プロンプトキュー設定コンポーネント（初期状態では非表示）
+ with gr.Group(visible=False) as prompt_queue_group:
+ # プロンプトキューファイル入力
+ prompt_queue_file = gr.File(
+ label=translate("プロンプトキューファイル (.txt) - 1行に1つのプロンプトが記載されたテキストファイル"),
+ file_types=[".txt"]
+ )
+ gr.Markdown(translate("※ ファイル内の各行が別々のプロンプトとして処理されます。\n※ チェックボックスがオフの場合は無効。\n※ バッチ処理回数より行数が多い場合は行数分処理されます。\n※ バッチ処理回数が1でもキュー回数が優先されます。"))
+
+ # イメージキュー設定コンポーネント（初期状態では非表示）
+ with gr.Group(visible=False) as image_queue_group:
+ gr.Markdown(translate("※ 1回目はImage画像を使用し、2回目以降は入力フォルダの画像ファイルを名前順に使用します。\n※ 画像と同名のテキストファイル（例：image1.jpg → image1.txt）があれば、その内容を自動的にプロンプトとして使用します。\n※ バッチ回数が全画像数を超える場合、残りはImage画像で処理されます。\n※ バッチ処理回数が1でもキュー回数が優先されます。"))
+
+ # 入力フォルダ設定
+ with gr.Row():
+ input_folder_name = gr.Textbox(
+ label=translate("入力フォルダ名"),
+ value=input_folder_name_value,
+ info=translate("入力画像ファイルを格納するフォルダ名")
+ )
+ open_input_folder_btn = gr.Button(value="📂 " + translate("保存及び入力フォルダを開く"), size="md")
+
+ # 入力フォルダ名の変更を検知してグローバル変数を更新する関数（設定保存はしない）
+ def update_input_folder(folder_name):
+ global input_folder_name_value
+ # 無効な文字を削除（パス区切り文字やファイル名に使えない文字）
+ folder_name = ''.join(c for c in folder_name if c.isalnum() or c in ('_', '-'))
+ input_folder_name_value = folder_name
+ print(translate("入力フォルダ名をメモリに保存: {0}（保存及び入力フォルダを開くボタンを押すと保存されます）").format(folder_name))
+ return gr.update(value=folder_name)
+
+ # 入力フォルダを開く関数
+ def open_input_folder():
+ """入力フォルダを開く処理（保存も実行）"""
+ global input_folder_name_value
+
+ # 念のため設定を保存
+ settings = load_settings()
+ settings['input_folder'] = input_folder_name_value
+ save_settings(settings)
+ print(translate("入力フォルダ設定を保存しました: {0}").format(input_folder_name_value))
+
+ # 入力フォルダのパスを取得
+ input_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), input_folder_name_value)
+
+ # フォルダが存在しなければ作成
+ if not os.path.exists(input_dir):
+ os.makedirs(input_dir, exist_ok=True)
+ print(translate("入力ディレクトリを作成しました: {0}").format(input_dir))
+
+ # 画像ファイルリストを更新
+ get_image_queue_files()
+
+ # フォルダを開く
+ open_folder(input_dir)
+ return None
+
+ # キュー機能のトグルハンドラー
+ def toggle_queue_settings(use_queue_val):
+ # グローバル変数を使用
+ global queue_enabled, queue_type
+
+ # チェックボックスの値をブール値に確実に変換
+ is_enabled = False
+
+ # Gradioオブジェクトの場合
+ if hasattr(use_queue_val, 'value'):
+ is_enabled = bool(use_queue_val.value)
+ else:
+ # 直接値の場合
+ is_enabled = bool(use_queue_val)
+
+ # グローバル変数を更新
+ queue_enabled = is_enabled
+
+ if is_enabled:
+ # キューが有効の場合
+ # キュータイプセレクタとキュータイプに応じたグループを表示
+ if queue_type == "prompt":
+ return [
+ gr.update(visible=True), # queue_type_selector
+ gr.update(visible=True), # prompt_queue_group
+ gr.update(visible=False) # image_queue_group
+ ]
+ else: # image
+ # イメージキュー選択時は画像ファイルリストを更新
+ get_image_queue_files()
+ return [
+ gr.update(visible=True), # queue_type_selector
+ gr.update(visible=False), # prompt_queue_group
+ gr.update(visible=True) # image_queue_group
+ ]
+ else:
+ # キューが無効の場合、すべて非表示
+ queue_enabled = False
+ return [
+ gr.update(visible=False), # queue_type_selector
+ gr.update(visible=False), # prompt_queue_group
+ gr.update(visible=False) # image_queue_group
+ ]
+
+ # キュータイプ切替ハンドラー
+ def toggle_queue_type(queue_type_val):
+ global queue_type
+
+ # キュータイプをグローバル変数に保存
+ if queue_type_val == translate("プロンプトキュー"):
+ queue_type = "prompt"
+ return [gr.update(visible=True), gr.update(visible=False)]
+ else:
+ queue_type = "image"
+ # イメージキューを選択した場合、画像ファイルリストを更新
+ get_image_queue_files()
+ return [gr.update(visible=False), gr.update(visible=True)]
+
+ # イベントハンドラーの登録
+ use_queue.change(
+ fn=toggle_queue_settings,
+ inputs=[use_queue],
+ outputs=[queue_type_selector, prompt_queue_group, image_queue_group]
+ )
+
+ # キュータイプ��選択イベントに関数を紐づけ
+ queue_type_selector.change(
+ fn=toggle_queue_type,
+ inputs=[queue_type_selector],
+ outputs=[prompt_queue_group, image_queue_group]
+ )
+
+ # 入力フォルダ名の変更イベントに関数を紐づけ
+ input_folder_name.change(
+ fn=update_input_folder,
+ inputs=[input_folder_name],
+ outputs=[input_folder_name]
+ )
+
+ # 入力フォルダを開くボタンにイベントを紐づけ
+ open_input_folder_btn.click(
+ fn=open_input_folder,
+ inputs=[],
+ outputs=[gr.Textbox(visible=False)] # 一時的なフィードバック表示用（非表示）
+ )
+
+ # 直接出力フォルダを開くボタンは削除（後で「保存および出力フォルダを開く」ボタンに置き換え）
+
+ # 生成開始/中止ボタン - endframe_ichiと完全に同じ実装
+ with gr.Row():
+ start_button = gr.Button(value=translate("Start Generation"))
+ end_button = gr.Button(value=translate("End Generation"), interactive=False)
+
+ # FP8最適化設定
+ with gr.Row():
+ fp8_optimization = gr.Checkbox(
+ label=translate("FP8 最適化"),
+ value=True,
+ info=translate("メモリ使用量を削減し速度を改善（PyTorch 2.1以上が必要）")
+ )
+
+ # 埋め込みプロンプト機能 - 参照用に定義（表示はLoRA設定の下で行う）
+ # グローバル変数として定義し、後で他の場所から参照できるようにする
+ global copy_metadata
+ copy_metadata = gr.Checkbox(
+ label=translate("埋め込みプロンプトおよびシードを複写する"),
+ value=False,
+ info=translate("チェックをオンにすると、画像のメタデータからプロンプトとシードを自動的に取得します"),
+ visible=False # 元の位置では非表示
+ )
+
+ # メタデータ抽出結果表示用（非表示）
+ extracted_info = gr.Markdown(visible=False)
+ extracted_prompt = gr.Textbox(visible=False)
+ extracted_seed = gr.Textbox(visible=False)
+
+ # 着せ替え設定 - 詳細設定の前に配置
+ gr.Markdown(f"### " + translate("Kisekaeichi 設定"))
+ gr.Markdown(translate("参照画像の特徴を入力画像に適用する一枚絵生成機能"))
+
+ # 参照画像を使用するかどうかのチェックボックス
+ use_reference_image = gr.Checkbox(
+ label=translate("参照画像を使用"),
+ value=False
+ )
+
+ # 参照画像の入力
+ reference_image = gr.Image(
+ sources=['upload', 'clipboard'],
+ label=translate("参照画像"),
+ type="filepath",
+ interactive=True,
+ visible=False, # 初期状態では非表示
+ height=320
+ )
+ # 参照画像の説明
+ reference_image_info = gr.Markdown(
+ translate("特徴を抽出する画像（スタイル、服装、背景など）"),
+ visible=False # 初期状態では非表示
+ )
+
+ # 高度な設定グループ
+ with gr.Group(visible=False) as advanced_kisekae_group:
+ gr.Markdown(f"#### " + translate("Kisekaeichi 詳細オプション"))
+
+ with gr.Row():
+ with gr.Column():
+ # ターゲットインデックス（公式実装に合わせて追加）
+ target_index = gr.Slider(
+ label=translate("ターゲットインデックス"),
+ minimum=0,
+ maximum=8,
+ value=saved_app_settings.get("target_index", 1) if saved_app_settings else 1, # PR #284推奨値
+ step=1,
+ elem_classes="saveable-setting"
+ )
+ target_index_info = gr.Markdown(
+ translate("開始画像の潜在空間での位置（0-8、推奨値1）")
+ )
+
+ # 履歴インデックス
+ history_index = gr.Slider(
+ label=translate("履歴インデックス"),
+ minimum=0,
+ maximum=16,
+ value=saved_app_settings.get("history_index", 16) if saved_app_settings else 16, # デフォルト値を16に設定
+ step=1,
+ elem_classes="saveable-setting"
+ )
+ history_index_info = gr.Markdown(
+ translate("参照画像の潜在空間での位置（0-16、デフォルト16、推奨値13）")
+ )
+
+ # 後処理ゼロ化オプション（削除）
+ # ノイズ問題と色の問題の両立が困難なため、zero_postオプションは削除
+
+
+ with gr.Row():
+ with gr.Column():
+ # 入力画像用マスク
+ input_mask = gr.Image(
+ sources=['upload', 'clipboard'],
+ label=translate("入力画像マスク（オプション）"),
+ type="filepath",
+ interactive=True,
+ height=320
+ )
+ input_mask_info = gr.Markdown(
+ translate("白い部分を保持、黒い部分を変更（グレースケール画像）")
+ )
+
+ with gr.Column():
+ # 参照画像用マスク
+ reference_mask = gr.Image(
+ sources=['upload', 'clipboard'],
+ label=translate("参照画像マスク（オプション）"),
+ type="filepath",
+ interactive=True,
+ height=320
+ )
+ reference_mask_info = gr.Markdown(
+ translate("白い部分を適用、黒い部分を無視（グレースケール画像）")
+ )
+
+ # 着せ替え設定の表示/非表示を切り替える関数
+ def toggle_kisekae_settings(use_reference):
+ # インデックスのデフォルト値を設定
+ target_index_value = 1 if use_reference else 0 # 参照画像使用時は1、未使用時は0に戻す
+ history_index_value = 16 if use_reference else 1 # 参照画像使用時は16、未使用時は1に戻す
+
+ return [
+ gr.update(visible=use_reference), # reference_image
+ gr.update(visible=use_reference), # advanced_kisekae_group
+ gr.update(visible=use_reference), # reference_image_info
+ gr.update(value=target_index_value), # target_index
+ gr.update(value=history_index_value) # history_index
+ ]
+
+ # イベントハンドラーの設定
+ use_reference_image.change(
+ toggle_kisekae_settings,
+ inputs=[use_reference_image],
+ outputs=[reference_image, advanced_kisekae_group, reference_image_info, target_index, history_index]
+ )
+
+ # 詳細設定アコーディオン - 埋め込みプロンプト機能の直後に配置
+ with gr.Accordion(translate("詳細設定"), open=False, elem_classes="section-accordion"):
+ # レイテント処理設定セクション
+ gr.Markdown(f"### " + translate("レイテント処理設定"))
+
+ with gr.Row():
+ with gr.Column(scale=1):
+ # ツイートに基づくRoPE値の設定
+ latent_window_size = gr.Slider(
+ label=translate("RoPE値 (latent_window_size)"),
+ minimum=1,
+ maximum=64,
+ value=saved_app_settings.get("latent_window_size", 9) if saved_app_settings else 9, # デフォルト値
+ step=1,
+ interactive=True, # 明示的に対話可能に設定
+ info=translate("動きの変化量に影響します。大きい値ほど大きな変化が発生します。モデルの内部調整用パラメータです。"),
+ elem_classes="saveable-setting"
+ )
+
+ with gr.Column(scale=1):
+ # レイテントインデックス
+ latent_index = gr.Slider(
+ label=translate("レイテントインデックス"),
+ minimum=0,
+ maximum=64,
+ value=saved_app_settings.get("latent_index", 0) if saved_app_settings else 0, # デフォルト値
+ step=1,
+ interactive=True, # 明示的に対話可能に設定
+ info=translate("0は基本、大きい値で衣装変更などの効果が得られる場合があります。値が大きいとノイズが増えます。"),
+ elem_classes="saveable-setting"
+ )
+
+ with gr.Row():
+ with gr.Column(scale=1):
+ # clean_latents_2xの有効/無効
+ use_clean_latents_2x = gr.Checkbox(
+ label=translate("clean_latents_2xを使用"),
+ value=saved_app_settings.get("use_clean_latents_2x", True) if saved_app_settings else True,
+ interactive=True, # 明示的に対話可能に設定
+ info=translate("オフにすると変化が発生します。画質や速度に影響があります"),
+ elem_classes="saveable-setting"
+ )
+
+ with gr.Column(scale=1):
+ # clean_latents_4xの有効/無効
+ use_clean_latents_4x = gr.Checkbox(
+ label=translate("clean_latents_4xを使用"),
+ value=saved_app_settings.get("use_clean_latents_4x", True) if saved_app_settings else True,
+ interactive=True, # 明示的に対話可能に設定
+ info=translate("オフにすると変化が発生します。画質や速度に影響があります"),
+ elem_classes="saveable-setting"
+ )
+
+ with gr.Row():
+ with gr.Column(scale=1):
+ # clean_latents_postの有効/無効
+ use_clean_latents_post = gr.Checkbox(
+ label=translate("clean_latents_postを使用"),
+ value=saved_app_settings.get("use_clean_latents_post", True) if saved_app_settings else True,
+ interactive=True, # 明示的に対話可能に設定
+ info=translate("オフにするとかなり速くなりますが、ノイズが増える可能性があります"),
+ elem_classes="saveable-setting"
+ )
+
+ # 前回選択したLoRAモードを保存するためのグローバル変数
+ global previous_lora_mode
+ if 'previous_lora_mode' not in globals():
+ previous_lora_mode = translate("ディレクトリから選択")
+
+ # LoRA設定 - endframe_ichiと同様の実装に拡張
+ if has_lora_support:
+ with gr.Group() as lora_settings_group:
+ gr.Markdown(f"### " + translate("LoRA設定"))
+
+ # LoRA使用有無のチェックボックス
+ use_lora = gr.Checkbox(label=translate("LoRAを使用する"), value=False, info=translate("チェックをオンにするとLoRAを使用します（要16GB VRAM以上）"))
+
+ # LoRAモード選択（初期状態では非表示）
+ lora_mode = gr.Radio(
+ choices=[translate("ディレクトリから選択"), translate("ファイルアップロード")],
+ value=translate("ディレクトリから選択"),
+ label=translate("LoRA読み込み方式"),
+ visible=False # 初期状態では非表示（toggle_lora_settingsで制御）
+ )
+
+ # ファイルアップロードグループ（初期状態では非表示）
+ with gr.Group(visible=False) as lora_upload_group:
+ # メインのLoRAファイル
+ lora_files = gr.File(
+ label=translate("LoRAファイル1 (.safetensors, .pt, .bin)"),
+ file_types=[".safetensors", ".pt", ".bin"]
+ )
+ # 追加のLoRAファイル
+ lora_files2 = gr.File(
+ label=translate("LoRAファイル2 (.safetensors, .pt, .bin)"),
+ file_types=[".safetensors", ".pt", ".bin"]
+ )
+ # 3つ目のLoRAファイル
+ lora_files3 = gr.File(
+ label=translate("LoRAファイル3 (.safetensors, .pt, .bin)"),
+ file_types=[".safetensors", ".pt", ".bin"]
+ )
+
+ # ディレクトリ選択グループ（初期状態では非表示）
+ with gr.Group(visible=False) as lora_dropdown_group:
+ # LoRAドロップダウン
+ none_choice = translate("なし")
+ lora_dropdown1 = gr.Dropdown(label=translate("LoRA1"), choices=[none_choice], value=none_choice)
+ lora_dropdown2 = gr.Dropdown(label=translate("LoRA2"), choices=[none_choice], value=none_choice)
+ lora_dropdown3 = gr.Dropdown(label=translate("LoRA3"), choices=[none_choice], value=none_choice)
+
+ # ドロップダウン更新ボタン（下に配置）
+ lora_scan_button = gr.Button(value=translate("LoRAフォルダを再スキャン"), variant="secondary")
+
+ # スケール値の入力フィールド
+ lora_scales_text = gr.Textbox(
+ label=translate("LoRA適用強度 (カンマ区切り)"),
+ value="0.8,0.8,0.8",
+ info=translate("各LoRAのスケール値をカンマ区切りで入力 (例: 0.8,0.5,0.3)"),
+ visible=False
+ )
+
+ # LoRAプリセット機能のインポート
+ from eichi_utils.lora_preset_manager import save_lora_preset, load_lora_preset
+
+ # LoRAプリセットグループ（初期状態では非表示）
+ with gr.Group(visible=False) as lora_preset_group:
+ # シンプルな1行レイアウト
+ with gr.Row():
+ # プリセット選択ボタン（1-5）
+ preset_buttons = []
+ for i in range(1, 6):
+ preset_buttons.append(
+ gr.Button(
+ translate("設定{0}").format(i),
+ variant="secondary",
+ scale=1
+ )
+ )
+
+ # Load/Save選択（ラベルなし、横並び）
+ with gr.Row(scale=1):
+ load_btn = gr.Button(translate("Load"), variant="primary", scale=1)
+ save_btn = gr.Button(translate("Save"), variant="secondary", scale=1)
+ # 内部的に使うRadio（非表示）
+ lora_preset_mode = gr.Radio(
+ choices=[translate("Load"), translate("Save")],
+ value=translate("Load"),
+ visible=False
+ )
+
+ # プリセット状態表示
+ lora_preset_status = gr.Textbox(
+ label=translate("プリセット状態"),
+ value="",
+ interactive=False,
+ lines=1
+ )
+
+ # LoRAディレクトリからファイル一覧を取得する関数
+ def scan_lora_directory():
+ """./loraディレクトリからLoRAモデルファイルを検索する関数"""
+ lora_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'lora')
+ choices = []
+
+ # ディレクトリが存在しない場合は作成
+ if not os.path.exists(lora_dir):
+ os.makedirs(lora_dir, exist_ok=True)
+ print(translate("LoRAディレクトリが存在しなかったため作成しました: {0}").format(lora_dir))
+
+ # ディレクトリ内のファイルをリストアップ
+ for filename in os.listdir(lora_dir):
+ if filename.endswith(('.safetensors', '.pt', '.bin')):
+ choices.append(filename)
+
+ # 空の選択肢がある場合は"なし"を追加
+ choices = sorted(choices)
+
+ # なしの選択肢を最初に追加
+ none_choice = translate("なし")
+ choices.insert(0, none_choice)
+
+ # 全ての選択肢が確実に文字列型であることを確認
+ for i, choice in enumerate(choices):
+ if not isinstance(choice, str):
+ # 明示的に文字列に変換
+ choices[i] = str(choice)
+
+ print(translate("LoRAディレクトリから{0}個のモデルを検出しました").format(len(choices) - 1))
+ return choices
+
+ # チェックボックスの状態によってLoRA設定の表示/非表示を切り替える関数
+ def toggle_lora_settings(use_lora):
+ # グローバル変数を使うように修正
+ global previous_lora_mode
+
+ # まだグローバル変数が定義されていなければ初期化
+ if 'previous_lora_mode' not in globals():
+ global previous_lora_mode
+ previous_lora_mode = translate("ディレクトリから選択")
+
+ # 現在のモード値を取得（UI要素が存在する場合）
+ current_mode = getattr(lora_mode, 'value', translate("ディレクトリから選択"))
+
+ # LoRAが無効化される場合、現在のモードを記憶
+ if not use_lora and current_mode:
+ previous_lora_mode = current_mode
+
+ if use_lora:
+ # LoRA使用時は前回のモードを復元
+ is_upload_mode = previous_lora_mode == translate("ファイルアップロード")
+
+ # 選択肢の更新
+ choices = scan_lora_directory() if not is_upload_mode else None
+
+ # モードに基づいた表示設定
+ preset_visible = not is_upload_mode # ディレクトリ選択モードの場合のみプリセット表示
+ return [
+ gr.update(visible=True, value=previous_lora_mode), # lora_mode - 前回の値を復元
+ gr.update(visible=is_upload_mode), # lora_upload_group
+ gr.update(visible=not is_upload_mode), # lora_dropdown_group
+ gr.update(visible=True), # lora_scales_text
+ gr.update(visible=preset_visible), # lora_preset_group
+ ]
+ else:
+ # LoRA不使用時はLoRA関連UIのみ非表示（FP8最適化は表示したまま）
+ return [
+ gr.update(visible=False), # lora_mode
+ gr.update(visible=False), # lora_upload_group
+ gr.update(visible=False), # lora_dropdown_group
+ gr.update(visible=False), # lora_scales_text
+ gr.update(visible=False), # lora_preset_group
+ ]
+
+ # LoRA読み込み方式に応じて表示を切り替える関数
+ def toggle_lora_mode(mode):
+ # 前回のモードを更新
+ global previous_lora_mode
+ previous_lora_mode = mode
+
+ if mode == translate("ディレクトリから選択"):
+ # ディレクトリから選択モードの場合
+ # 最初にディレクトリをスキャン
+ choices = scan_lora_directory()
+
+ # 選択肢が確実に更新されるようにする
+ return [
+ gr.update(visible=False), # lora_upload_group
+ gr.update(visible=True), # lora_dropdown_group
+ gr.update(visible=True), # lora_preset_group
+ gr.update(choices=choices, value=choices[0]), # lora_dropdown1
+ gr.update(choices=choices, value=choices[0]), # lora_dropdown2
+ gr.update(choices=choices, value=choices[0]) # lora_dropdown3
+ ]
+ else: # ファイルアップロード
+ # ファイルアップロード方式の場合、ドロップダウンの値は更新しない
+ return [
+ gr.update(visible=True), # lora_upload_group
+ gr.update(visible=False), # lora_dropdown_group
+ gr.update(visible=False), # lora_preset_group
+ gr.update(), # lora_dropdown1 - 変更なし
+ gr.update(), # lora_dropdown2 - 変更なし
+ gr.update() # lora_dropdown3 - 変更なし
+ ]
+
+ # スキャンボタンの処理関数
+ def update_lora_dropdowns():
+ choices = scan_lora_directory()
+ # 各ドロップダウンを更新
+ return [
+ gr.update(choices=choices, value=choices[0]), # lora_dropdown1
+ gr.update(choices=choices, value=choices[0]), # lora_dropdown2
+ gr.update(choices=choices, value=choices[0]), # lora_dropdown3
+ ]
+
+ # LoRA使用チェックボックスの切り替え後にドロップダウンを更新する統合関数
+ def toggle_lora_full_update(use_lora_val):
+ global previous_lora_mode
+
+ # まずLoRA設定全体の表示/非表示を切り替え
+ mode_updates = toggle_lora_settings(use_lora_val)
+
+ # LoRAが有効で、かつディレクトリ選択モード時にドロップダウンを更新
+ if use_lora_val and previous_lora_mode == translate("ディレクトリから選択"):
+ choices = scan_lora_directory()
+ # ドロップダウン更新
+ dropdown_updates = [
+ gr.update(choices=choices, value=choices[0]), # lora_dropdown1
+ gr.update(choices=choices, value=choices[0]), # lora_dropdown2
+ gr.update(choices=choices, value=choices[0]) # lora_dropdown3
+ ]
+ return mode_updates + dropdown_updates
+
+ # それ以外の場合は変更なし
+ return mode_updates + [gr.update(), gr.update(), gr.update()]
+
+ # チェックボックスの変更イベントに統合関数を紐づけ
+ use_lora.change(
+ fn=toggle_lora_full_update,
+ inputs=[use_lora],
+ outputs=[lora_mode, lora_upload_group, lora_dropdown_group,
+ lora_scales_text, lora_preset_group,
+ lora_dropdown1, lora_dropdown2, lora_dropdown3]
+ )
+
+ # LoRA読み込み方式の変更イベントに表示切替関数を紐づけ
+ lora_mode.change(
+ fn=toggle_lora_mode,
+ inputs=[lora_mode],
+ outputs=[lora_upload_group, lora_dropdown_group, lora_preset_group, lora_dropdown1, lora_dropdown2, lora_dropdown3]
+ )
+
+ # スキャンボタンの処理を紐づけ
+ lora_scan_button.click(
+ fn=update_lora_dropdowns,
+ inputs=[],
+ outputs=[lora_dropdown1, lora_dropdown2, lora_dropdown3]
+ )
+
+ # LoRAタイプとプリセット表示の組み合わせを制御する関数
+ def toggle_lora_and_preset(use_lora_val, lora_mode_val):
+ # LoRAが有効かつディレクトリから選択モードの場合のみプリセットを表示
+ preset_visible = use_lora_val and lora_mode_val == translate("ディレクトリから選択")
+ return gr.update(visible=preset_visible)
+
+ # LoRAプリセット機能のハンドラー関数
+ def handle_lora_preset_button(button_index, mode, lora1, lora2, lora3, scales):
+ """LoRAプリセットボタンのクリックを処理する"""
+ if mode == translate("Load"): # Load
+ # ロードモード
+ loaded_values = load_lora_preset(button_index)
+ if loaded_values:
+ return (
+ gr.update(value=loaded_values[0]), # lora_dropdown1
+ gr.update(value=loaded_values[1]), # lora_dropdown2
+ gr.update(value=loaded_values[2]), # lora_dropdown3
+ gr.update(value=loaded_values[3]), # lora_scales_text
+ translate("設定{0}を読み込みました").format(button_index + 1) # status
+ )
+ else:
+ return (
+ gr.update(), gr.update(), gr.update(), gr.update(),
+ translate("設定{0}の読み込みに失敗しました").format(button_index + 1)
+ )
+ else:
+ # セーブモード
+ success, message = save_lora_preset(button_index, lora1, lora2, lora3, scales)
+ return (
+ gr.update(), gr.update(), gr.update(), gr.update(),
+ message
+ )
+
+ # Load/Saveボタンのイベントハンドラー
+ def set_load_mode():
+ return (
+ gr.update(value=translate("Load")),
+ gr.update(variant="primary"),
+ gr.update(variant="secondary")
+ )
+
+ def set_save_mode():
+ return (
+ gr.update(value=translate("Save")),
+ gr.update(variant="secondary"),
+ gr.update(variant="primary")
+ )
+
+ # イベントの設定
+ # プリセットボタンのイベント
+ for i, btn in enumerate(preset_buttons):
+ btn.click(
+ fn=lambda mode, lora1, lora2, lora3, scales, idx=i: handle_lora_preset_button(
+ idx, mode, lora1, lora2, lora3, scales
+ ),
+ inputs=[lora_preset_mode, lora_dropdown1, lora_dropdown2, lora_dropdown3, lora_scales_text],
+ outputs=[lora_dropdown1, lora_dropdown2, lora_dropdown3, lora_scales_text, lora_preset_status]
+ )
+
+ # Load/Saveボタンのイベント
+ load_btn.click(
+ set_load_mode,
+ outputs=[lora_preset_mode, load_btn, save_btn]
+ )
+
+ save_btn.click(
+ set_save_mode,
+ outputs=[lora_preset_mode, load_btn, save_btn]
+ )
+
+ # LoRA使用状態とモードの変更でプリセット表示を更新
+ use_lora.change(
+ toggle_lora_and_preset,
+ inputs=[use_lora, lora_mode],
+ outputs=[lora_preset_group]
+ )
+
+ lora_mode.change(
+ toggle_lora_and_preset,
+ inputs=[use_lora, lora_mode],
+ outputs=[lora_preset_group]
+ )
+
+ # UIロード後に自動的に初期化ボタンをクリックするJavaScriptを追加
+ js_init_code = """
+ function initLoraDropdowns() {
+ // UIロード後、少し待ってからボタンをクリック
+ setTimeout(function() {
+ // LoRAフォルダを再スキャンボタンを探して自動クリック
+ var scanBtns = document.querySelectorAll('button');
+ var scanBtn = null;
+
+ for (var i = 0; i < scanBtns.length; i++) {
+ if (scanBtns[i].textContent.includes('LoRAフォルダを再スキャン')) {
+ scanBtn = scanBtns[i];
+ break;
+ }
+ }
+
+ if (scanBtn) {
+ console.log('LoRAドロップダウン初期化ボタンを自動実行します');
+ scanBtn.click();
+ }
+ }, 1000); // 1秒待ってから実行
+ }
+
+ // ページロード時に初期化関数を呼び出し
+ window.addEventListener('load', initLoraDropdowns);
+ """
+
+ # JavaScriptコードをUIに追加
+ gr.HTML(f"")
+
+ # LoRAサポートが無効の場合のメッセージ
+ if not has_lora_support:
+ gr.Markdown(translate("LoRAサポートは現在無効です。lora_utilsモジュールが必要です。"))
+ else:
+ # LoRAサポートが無効の場合はダミー変数を作成
+ use_lora = gr.Checkbox(visible=False, value=False)
+ lora_mode = gr.Radio(visible=False, value=translate("��ィレクトリから選択"))
+ lora_upload_group = gr.Group(visible=False)
+ lora_dropdown_group = gr.Group(visible=False)
+ lora_files = gr.File(visible=False)
+ lora_files2 = gr.File(visible=False)
+ lora_files3 = gr.File(visible=False)
+ lora_dropdown1 = gr.Dropdown(visible=False)
+ lora_dropdown2 = gr.Dropdown(visible=False)
+ lora_dropdown3 = gr.Dropdown(visible=False)
+ lora_scales_text = gr.Textbox(visible=False, value="0.8,0.8,0.8")
+ lora_preset_group = gr.Group(visible=False) # ダミー
+
+ # LoRA設定の下に埋め込みプロンプトおよびシードを複写するチェックボックスを表示
+ # 埋め込みプロンプトおよびシードを複写するチェックボックス（LoRA設定の下に表示）
+ copy_metadata_visible = gr.Checkbox(
+ label=translate("埋め込みプロンプトおよびシードを複写する"),
+ value=False,
+ info=translate("チェックをオンにすると、画像のメタデータからプロンプトとシードを自動的に取得します")
+ )
+
+ # 表示用チェックボックスと実際の処理用チェックボックスを同期
+ copy_metadata_visible.change(
+ fn=lambda x: x,
+ inputs=[copy_metadata_visible],
+ outputs=[copy_metadata]
+ )
+
+ # 元のチェックボックスが変更されたときも表示用を同期
+ copy_metadata.change(
+ fn=lambda x: x,
+ inputs=[copy_metadata],
+ outputs=[copy_metadata_visible],
+ queue=False # 高速化のためキューをスキップ
+ )
+
+ # プロンプト入力
+ prompt = gr.Textbox(label=translate("プロンプト"), value=get_default_startup_prompt(), lines=6)
+ n_prompt = gr.Textbox(label=translate("ネガティブプロンプト"), value='', visible=False)
+
+ # プロンプト管理パネル
+ with gr.Group(visible=True) as prompt_management:
+ gr.Markdown(f"### " + translate("プロンプト管理"))
+
+ # 編集画面を常時表示する
+ with gr.Group(visible=True):
+ # 起動時デフォルトの初期表示用に取得
+ default_prompt = ""
+ default_name = ""
+ for preset in load_presets()["presets"]:
+ if preset.get("is_startup_default", False):
+ default_prompt = preset["prompt"]
+ default_name = preset["name"]
+ break
+
+ with gr.Row():
+ edit_name = gr.Textbox(label=translate("プリセット名"), placeholder=translate("名前を入力..."), value=default_name)
+
+ edit_prompt = gr.Textbox(label=translate("プロンプト"), lines=5, value=default_prompt)
+
+ with gr.Row():
+ # 起動時デフォルトをデフォルト選択に設定
+ default_preset = translate("起動時デフォルト")
+ # プリセットデータから全プリセット名を取得
+ presets_data = load_presets()
+ choices = [preset["name"] for preset in presets_data["presets"]]
+ default_presets = [name for name in choices if any(p["name"] == name and p.get("is_default", False) for p in presets_data["presets"])]
+ user_presets = [name for name in choices if name not in default_presets]
+ sorted_choices = [(name, name) for name in sorted(default_presets) + sorted(user_presets)]
+ preset_dropdown = gr.Dropdown(label=translate("プリセット"), choices=sorted_choices, value=default_preset, type="value")
+
+ with gr.Row():
+ save_btn = gr.Button(value=translate("保存"), variant="primary")
+ apply_preset_btn = gr.Button(value=translate("反映"), variant="primary")
+ clear_btn = gr.Button(value=translate("クリア"))
+ delete_preset_btn = gr.Button(value=translate("削除"))
+
+ # メッセージ表示用
+ result_message = gr.Markdown("")
+
+ with gr.Column(scale=1):
+ # 右カラム - 生成結果と設定
+ result_image = gr.Image(label=translate("生成結果"), height=512)
+ preview_image = gr.Image(label=translate("処理中のプレビュー"), height=200, visible=False)
+ progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
+ progress_bar = gr.HTML('', elem_classes='no-generating-animation')
+
+ # endframe_ichiと同じ順序で設定項目を配置
+ # TeaCacheとランダムシード設定
+ use_teacache = gr.Checkbox(label=translate('Use TeaCache'), value=saved_app_settings.get("use_teacache", True) if saved_app_settings else True, info=translate('Faster speed, but often makes hands and fingers slightly worse.'), elem_classes="saveable-setting")
+
+ # Use Random Seedの初期値
+ use_random_seed = gr.Checkbox(label=translate("Use Random Seed"), value=use_random_seed_default)
+ seed = gr.Number(label=translate("Seed"), value=seed_default, precision=0)
+
+ # ステップ数などの設定を右カラムに配置
+ steps = gr.Slider(label=translate("ステップ数"), minimum=1, maximum=100, value=saved_app_settings.get("steps", 25) if saved_app_settings else 25, step=1, info=translate('この値の変更は推奨されません'), elem_classes="saveable-setting")
+ gs = gr.Slider(label=translate("蒸留CFGスケール"), minimum=1.0, maximum=32.0, value=saved_app_settings.get("gs", 10.0) if saved_app_settings else 10.0, step=0.01, info=translate('この値の変更は推奨されません'), elem_classes="saveable-setting")
+
+ # 非表示設定
+ cfg = gr.Slider(label="CFG Scale", minimum=1.0, maximum=32.0, value=saved_app_settings.get("cfg", 1) if saved_app_settings else 1, step=0.01, visible=False, elem_classes="saveable-setting")
+ rs = gr.Slider(label="CFG Re-Scale", minimum=0.0, maximum=1.0, value=0.0, step=0.01, visible=False)
+
+ # GPU設定
+ gpu_memory_preservation = gr.Slider(
+ label=translate("GPUメモリ保持 (GB)"),
+ minimum=6, maximum=128, value=saved_app_settings.get("gpu_memory_preservation", 6) if saved_app_settings else 6, step=0.1,
+ info=translate("OOMが発生する場合は値を大きくしてください。値が大きいほど速度が遅くなります。"),
+ elem_classes="saveable-setting"
+ )
+
+ # GPUメモリ保持部分のみ残し、詳細設定アコーディオンは削除（すでに移動済み）
+
+ # 出力設定はシード値の下に配置 - endframe_ichiと同じ実装にする
+ with gr.Group():
+ gr.Markdown(f"### " + translate("出力設定"))
+
+ with gr.Row(equal_height=True):
+ with gr.Column(scale=4):
+ # フォルダ名だけを入力欄に設定
+ output_dir = gr.Textbox(
+ label=translate("出力フォルダ名"),
+ value=output_folder_name, # 設定から読み込んだ値を使用
+ info=translate("生成画像の保存先フォルダ名"),
+ placeholder="outputs"
+ )
+ with gr.Column(scale=1, min_width=100):
+ open_folder_btn = gr.Button(value=translate("📂 保存および出力フォルダを開く"), size="sm")
+
+ # 実際の出力パスを表示
+ with gr.Row(visible=False):
+ path_display = gr.Textbox(
+ label=translate("出力フォルダの完全パス"),
+ value=os.path.join(base_path, output_folder_name),
+ interactive=False
+ )
+
+ # 設定保存UI
+ with gr.Group():
+ gr.Markdown(f"### " + translate("アプリケーション設定"))
+ with gr.Row():
+ with gr.Column(scale=1):
+ save_current_settings_btn = gr.Button(value=translate("💾 現在の設定を保存"), size="sm")
+ with gr.Column(scale=1):
+ reset_settings_btn = gr.Button(value=translate("🔄 設定をリセット"), size="sm")
+
+ # 自動保存設定
+ save_settings_on_start = gr.Checkbox(
+ label=translate("生成開始時に自動保存"),
+ value=saved_app_settings.get("save_settings_on_start", False) if saved_app_settings else False,
+ info=translate("チェックをオンにすると、生成開始時に現在の設定が自動的に保存されます。設定は再起動時に反映されます。"),
+ elem_classes="saveable-setting",
+ interactive=True
+ )
+
+ # 完了時のアラーム設定
+ alarm_on_completion = gr.Checkbox(
+ label=translate("完了時にアラームを鳴らす(Windows)"),
+ value=saved_app_settings.get("alarm_on_completion", True) if saved_app_settings else True,
+ info=translate("チェックをオンにすると、生成完了時にアラーム音を鳴らします（Windows）"),
+ elem_classes="saveable-setting",
+ interactive=True
+ )
+
+ # ログ設定
+ gr.Markdown("### " + translate("ログ設定"))
+
+ # 設定からログ設定を読み込む
+ all_settings = load_settings()
+ log_settings = all_settings.get('log_settings', {'log_enabled': False, 'log_folder': 'logs'})
+
+ # ログ有効/無効設定
+ log_enabled = gr.Checkbox(
+ label=translate("コンソールログを出力する"),
+ value=log_settings.get('log_enabled', False),
+ info=translate("チェックをオンにすると、コンソール出力をログファイルにも保存します"),
+ elem_classes="saveable-setting",
+ interactive=True
+ )
+
+ # ログ出力先設定
+ log_folder = gr.Textbox(
+ label=translate("ログ出力先"),
+ value=log_settings.get('log_folder', 'logs'),
+ info=translate("ログファイルの保存先フォルダを指定します"),
+ elem_classes="saveable-setting",
+ interactive=True
+ )
+
+ # ログフォルダを開くボタン
+ open_log_folder_btn = gr.Button(value=translate("📂 ログフォルダを開く"), size="sm")
+
+ # ログフォルダを開くボタンのクリックイベント
+ open_log_folder_btn.click(fn=open_log_folder)
+
+ # 設定状態の表示
+ settings_status = gr.Markdown("")
+
+ # アプリケーション設定の保存機能
+ def save_app_settings_handler(
+ # 保存対象の設定項目
+ resolution_val,
+ steps_val,
+ cfg_val,
+ use_teacache_val,
+ gpu_memory_preservation_val,
+ gs_val,
+ latent_window_size_val,
+ latent_index_val,
+ use_clean_latents_2x_val,
+ use_clean_latents_4x_val,
+ use_clean_latents_post_val,
+ target_index_val,
+ history_index_val,
+ save_settings_on_start_val,
+ alarm_on_completion_val,
+ # ログ設定項目
+ log_enabled_val,
+ log_folder_val
+ ):
+ """現在の設定を保存"""
+ current_settings = {
+ 'resolution': resolution_val,
+ 'steps': steps_val,
+ 'cfg': cfg_val,
+ 'use_teacache': use_teacache_val,
+ 'gpu_memory_preservation': gpu_memory_preservation_val,
+ 'gs': gs_val,
+ 'latent_window_size': latent_window_size_val,
+ 'latent_index': latent_index_val,
+ 'use_clean_latents_2x': use_clean_latents_2x_val,
+ 'use_clean_latents_4x': use_clean_latents_4x_val,
+ 'use_clean_latents_post': use_clean_latents_post_val,
+ 'target_index': target_index_val,
+ 'history_index': history_index_val,
+ 'save_settings_on_start': save_settings_on_start_val,
+ 'alarm_on_completion': alarm_on_completion_val
+ }
+
+ # アプリ設定を保存
+ try:
+ app_success = save_app_settings_oichi(current_settings)
+ except Exception as e:
+ return translate("設定の保存に失敗しました: {0}").format(str(e))
+
+ # ログ設定も保存 - 値の型を確認
+ # log_enabledはbooleanに確実に変換
+ is_log_enabled = False
+ if isinstance(log_enabled_val, bool):
+ is_log_enabled = log_enabled_val
+ elif hasattr(log_enabled_val, 'value'):
+ is_log_enabled = bool(log_enabled_val.value)
+
+ # log_folderは文字列に確実に変換
+ log_folder_path = "logs"
+ if log_folder_val and isinstance(log_folder_val, str):
+ log_folder_path = log_folder_val
+ elif hasattr(log_folder_val, 'value') and log_folder_val.value:
+ log_folder_path = str(log_folder_val.value)
+
+ log_settings = {
+ "log_enabled": is_log_enabled,
+ "log_folder": log_folder_path
+ }
+
+ # 全体設定を取得し、ログ設定を更新
+ all_settings = load_settings()
+ all_settings['log_settings'] = log_settings
+ log_success = save_settings(all_settings)
+
+ # ログ設定を適用（設定保存後、すぐに新しいログ設定を反映）
+ if log_success:
+ # 一旦ログを無効化
+ disable_logging()
+ # 新しい設定でログを再開（有効な場合）
+ apply_log_settings(log_settings, source_name="oneframe_ichi")
+ print(translate("ログ設定を更新しました: 有効={0}, フォルダ={1}").format(
+ log_enabled_val, log_folder_val))
+
+ if app_success and log_success:
+ return translate("設定を保存しました")
+ else:
+ return translate("設定の一部保存に失敗しました")
+
+ def reset_app_settings_handler():
+ """設定をデフォルトに戻す"""
+ from eichi_utils.settings_manager import get_default_app_settings_oichi
+
+ default_settings = get_default_app_settings_oichi()
+ updates = []
+
+ # 各UIコンポーネントのデフォルト値を設定
+ updates.append(gr.update(value=default_settings.get("resolution", 640))) # 1
+ updates.append(gr.update(value=default_settings.get("steps", 25))) # 2
+ updates.append(gr.update(value=default_settings.get("cfg", 1))) # 3
+ updates.append(gr.update(value=default_settings.get("use_teacache", True))) # 4
+ updates.append(gr.update(value=default_settings.get("gpu_memory_preservation", 6))) # 5
+ updates.append(gr.update(value=default_settings.get("gs", 10))) # 6
+ updates.append(gr.update(value=default_settings.get("latent_window_size", 9))) # 7
+ updates.append(gr.update(value=default_settings.get("latent_index", 0))) # 8
+ updates.append(gr.update(value=default_settings.get("use_clean_latents_2x", True))) # 9
+ updates.append(gr.update(value=default_settings.get("use_clean_latents_4x", True))) # 10
+ updates.append(gr.update(value=default_settings.get("use_clean_latents_post", True))) # 11
+ updates.append(gr.update(value=default_settings.get("target_index", 1))) # 12
+ updates.append(gr.update(value=default_settings.get("history_index", 16))) # 13
+ updates.append(gr.update(value=default_settings.get("save_settings_on_start", False))) # 14
+ updates.append(gr.update(value=default_settings.get("alarm_on_completion", True))) # 15
+
+ # ログ設定 (16番目め17番目の要素)
+ # ログ設定は固定値を使用 - 絶対に文字列とbooleanを使用
+ updates.append(gr.update(value=False)) # log_enabled (16)
+ updates.append(gr.update(value="logs")) # log_folder (17)
+
+ # ログ設定をアプリケーションに適用
+ default_log_settings = {
+ "log_enabled": False,
+ "log_folder": "logs"
+ }
+
+ # 設定ファイルを更新
+ all_settings = load_settings()
+ all_settings['log_settings'] = default_log_settings
+ save_settings(all_settings)
+
+ # ログ設定を適用 (既存のログファイルを閉じて、設定に従って再設定)
+ disable_logging() # 既存のログを閉じる
+
+ # 設定状態メッセージ (18番目の要素)
+ updates.append(translate("設定をデフォルトに戻しました"))
+
+ return updates
+
+ # シードのランダム化機能
+ def set_random_seed(is_checked):
+ if is_checked:
+ return random.randint(0, 2**32 - 1)
+ return gr.update()
+
+ # チェックボックス変更時にランダムシードを生成
+ use_random_seed.change(fn=set_random_seed, inputs=use_random_seed, outputs=seed)
+
+ # バッチ処理回数に応じてランダムシードを扱う処理
+ def randomize_seed_if_needed(use_random, batch_num=1):
+ """バッチ処理用のシード設定関数"""
+ if use_random:
+ # ランダムシードの場合はバッチごとに異なるシードを生成
+ random_seeds = [random.randint(0, 2**32 - 1) for _ in range(batch_num)]
+ return random_seeds[0] # 最初のシードを返す（表示用）
+ return gr.update() # ランダムシードでな���場合は何もしない
+
+ # プリセット管理に関するイベントハンドラ
+ # プリセット保存ボタンのイベント
+ def save_button_click_handler(name, prompt_text):
+ """保存ボタンクリック時のハンドラ関数"""
+ # 重複チェックと正規化
+ if "A character" in prompt_text and prompt_text.count("A character") > 1:
+ sentences = prompt_text.split(".")
+ if len(sentences) > 0:
+ prompt_text = sentences[0].strip() + "."
+ # 重複を検出したため正規化
+
+ # プリセット保存
+ result_msg = save_preset(name, prompt_text)
+
+ # プリセットデータを取得してドロップダウンを更新
+ presets_data = load_presets()
+ choices = [preset["name"] for preset in presets_data["presets"]]
+ default_presets = [n for n in choices if any(p["name"] == n and p.get("is_default", False) for p in presets_data["presets"])]
+ user_presets = [n for n in choices if n not in default_presets]
+ sorted_choices = [(n, n) for n in sorted(default_presets) + sorted(user_presets)]
+
+ # メインプロンプトは更新しない（保存のみを行う）
+ return result_msg, gr.update(choices=sorted_choices), gr.update()
+
+ # クリアボタン処理
+ def clear_fields():
+ return gr.update(value=""), gr.update(value="")
+
+ # プリセット読込処理
+ def load_preset_handler(preset_name):
+ # プリセット選択時に編集欄のみを更新
+ for preset in load_presets()["presets"]:
+ if preset["name"] == preset_name:
+ return gr.update(value=preset_name), gr.update(value=preset["prompt"])
+ return gr.update(), gr.update()
+
+ # プリセット選択時に編集欄に反映
+ def load_preset_handler_wrapper(preset_name):
+ # プリセット名がタプルの場合も処理する
+ if isinstance(preset_name, tuple) and len(preset_name) == 2:
+ preset_name = preset_name[1] # 値部分を取得
+ return load_preset_handler(preset_name)
+
+ # 反映ボタン処理 - 編集画面の内容をメインプロンプトに反映
+ def apply_to_prompt(edit_text):
+ """編集画面の内容をメインプロンプトに反映する関数"""
+ # 編集画面のプロンプトをメインに適用
+ return gr.update(value=edit_text)
+
+ # プリセット削除処理
+ def delete_preset_handler(preset_name):
+ # プリセット名がタプルの場合も処理する
+ if isinstance(preset_name, tuple) and len(preset_name) == 2:
+ preset_name = preset_name[1] # 値部分を取得
+
+ result = delete_preset(preset_name)
+
+ # プリセットデータを取得してドロップダウンを更新
+ presets_data = load_presets()
+ choices = [preset["name"] for preset in presets_data["presets"]]
+ default_presets = [name for name in choices if any(p["name"] == name and p.get("is_default", False) for p in presets_data["presets"])]
+ user_presets = [name for name in choices if name not in default_presets]
+ sorted_names = sorted(default_presets) + sorted(user_presets)
+ updated_choices = [(name, name) for name in sorted_names]
+
+ return result, gr.update(choices=updated_choices)
+
+ # 保存ボタンのクリックイベントを接続
+ save_btn.click(
+ fn=save_button_click_handler,
+ inputs=[edit_name, edit_prompt],
+ outputs=[result_message, preset_dropdown, prompt]
+ )
+
+ # クリアボタンのクリックイベントを接続
+ clear_btn.click(
+ fn=clear_fields,
+ inputs=[],
+ outputs=[edit_name, edit_prompt]
+ )
+
+ # プリセット選択時のイベントを接続
+ preset_dropdown.change(
+ fn=load_preset_handler_wrapper,
+ inputs=[preset_dropdown],
+ outputs=[edit_name, edit_prompt]
+ )
+
+ # 反映ボタンのクリックイベントを接続
+ apply_preset_btn.click(
+ fn=apply_to_prompt,
+ inputs=[edit_prompt],
+ outputs=[prompt]
+ )
+
+ # 削除ボタンのクリックイベントを接続
+ delete_preset_btn.click(
+ fn=delete_preset_handler,
+ inputs=[preset_dropdown],
+ outputs=[result_message, preset_dropdown]
+ )
+
+ # 画像変更時にメタデータを抽出するイベント設定
+ input_image.change(
+ fn=update_from_image_metadata,
+ inputs=[input_image, copy_metadata],
+ outputs=[prompt, seed]
+ )
+
+ # チェックボックス変更時にメタデータを抽出するイベント設定
+ copy_metadata.change(
+ fn=check_metadata_on_checkbox_change,
+ inputs=[copy_metadata, input_image],
+ outputs=[prompt, seed]
+ )
+
+ # フォルダを開くボタンのイベント
+ open_folder_btn.click(
+ fn=handle_open_folder_btn,
+ inputs=[output_dir],
+ outputs=[output_dir, path_display]
+ )
+
+ # 生成開始・中止のイベント
+ ips = [input_image, prompt, n_prompt, seed, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache,
+ lora_files, lora_files2, lora_scales_text, use_lora, fp8_optimization, resolution, output_dir,
+ batch_count, use_random_seed, latent_window_size, latent_index,
+ use_clean_latents_2x, use_clean_latents_4x, use_clean_latents_post,
+ lora_mode, lora_dropdown1, lora_dropdown2, lora_dropdown3, lora_files3, use_rope_batch,
+ use_queue, prompt_queue_file, # キュー機能パラメータを追加
+ # Kisekaeichi関連パラメータを追加
+ use_reference_image, reference_image,
+ target_index, history_index, input_mask, reference_mask,
+ save_settings_on_start, alarm_on_completion] # 設定保存パラメータを追加
+
+ # 設定保存ボタンのクリックイベント
+ save_current_settings_btn.click(
+ fn=save_app_settings_handler,
+ inputs=[
+ resolution,
+ steps,
+ cfg,
+ use_teacache,
+ gpu_memory_preservation,
+ gs,
+ latent_window_size,
+ latent_index,
+ use_clean_latents_2x,
+ use_clean_latents_4x,
+ use_clean_latents_post,
+ target_index,
+ history_index,
+ save_settings_on_start,
+ alarm_on_completion,
+ log_enabled,
+ log_folder
+ ],
+ outputs=[settings_status]
+ )
+
+ # 設定リセットボタンのクリックイベント
+ reset_settings_btn.click(
+ fn=reset_app_settings_handler,
+ inputs=[],
+ outputs=[
+ resolution, # 1
+ steps, # 2
+ cfg, # 3
+ use_teacache, # 4
+ gpu_memory_preservation, # 5
+ gs, # 6
+ latent_window_size, # 7
+ latent_index, # 8
+ use_clean_latents_2x, # 9
+ use_clean_latents_4x, # 10
+ use_clean_latents_post, # 11
+ target_index, # 12
+ history_index, # 13
+ save_settings_on_start, # 14
+ alarm_on_completion, # 15
+ log_enabled, # 16
+ log_folder, # 17
+ settings_status # 18
+ ]
+ )
+
+ start_button.click(fn=process, inputs=ips, outputs=[result_image, preview_image, progress_desc, progress_bar, start_button, end_button])
+ end_button.click(fn=end_process, outputs=[end_button])
+
+ gr.HTML(f'{translate("FramePack 単一フレーム生成版")}
')
+
+block.launch(
+ server_name=args.server,
+ server_port=args.port,
+ share=args.share,
+ inbrowser=args.inbrowser,
+)
\ No newline at end of file