Update app.py

app.py

@@ -18,153 +18,227 @@ import safetensors.torch as sf
 import numpy as np
 import math
 
-# Hugging Face Space環境内かどうか確認
+# Check if running in Hugging Face Space
 IN_HF_SPACE = os.environ.get('SPACE_ID') is not None
 
-# GPU利用可能性を追跡する変数を追加
+# Track GPU availability
 GPU_AVAILABLE = False
 GPU_INITIALIZED = False
 last_update_time = time.time()
 
-# Hugging Face Space内の場合、spacesモジュールをインポート
+# If running in a HF Space, import spaces
 if IN_HF_SPACE:
     try:
         import spaces
-        print("Hugging Face Space環境内で実行中、spacesモジュールをインポートしました")
+        print("Running inside a Hugging Face Space, 'spaces' module imported.")
         
-        # GPU利用可能性をチェック
         try:
             GPU_AVAILABLE = torch.cuda.is_available()
-            print(f"GPU利用可能: {GPU_AVAILABLE}")
+            print(f"GPU available: {GPU_AVAILABLE}")
             if GPU_AVAILABLE:
-                print(f"GPUデバイス名: {torch.cuda.get_device_name(0)}")
-                print(f"GPUメモリ: {torch.cuda.get_device_properties(0).total_memory / 1e9} GB")
+                print(f"GPU device name: {torch.cuda.get_device_name(0)}")
+                print(f"GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1e9} GB")
                 
-                # 小規模なGPU操作を試行し、GPUが実際に使用可能か確認
-                test_tensor = torch.zeros(1, device='cuda')
-                test_tensor = test_tensor + 1
+                # Small GPU operation test
+                test_tensor = torch.zeros(1, device='cuda') + 1
                 del test_tensor
-                print("GPUテスト操作に成功しました")
+                print("GPU test operation succeeded.")
             else:
-                print("警告: CUDAが利用可能と報告されていますが、GPUデバイスが検出されませんでした")
+                print("Warning: CUDA says it's available, but no GPU device was detected.")
         except Exception as e:
             GPU_AVAILABLE = False
-            print(f"GPU確認中にエラーが発生しました: {e}")
-            print("CPUモードで実行します")
+            print(f"Error checking GPU: {e}")
+            print("Falling back to CPU mode.")
     except ImportError:
-        print("spacesモジュールのインポートに失敗しました。Hugging Face Space環境外かもしれません")
+        print("Could not import 'spaces' module. Possibly not in a HF Space.")
         GPU_AVAILABLE = torch.cuda.is_available()
 
 from PIL import Image
 from diffusers import AutoencoderKLHunyuanVideo
-from transformers import LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer
-from diffusers_helper.hunyuan import encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
-from diffusers_helper.utils import save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw, resize_and_center_crop, state_dict_weighted_merge, state_dict_offset_merge, generate_timestamp
+from transformers import (
+    LlamaModel, 
+    CLIPTextModel, 
+    LlamaTokenizerFast, 
+    CLIPTokenizer, 
+    SiglipImageProcessor, 
+    SiglipVisionModel
+)
+from diffusers_helper.hunyuan import (
+    encode_prompt_conds, 
+    vae_decode, 
+    vae_encode, 
+    vae_decode_fake
+)
+from diffusers_helper.utils import (
+    save_bcthw_as_mp4, 
+    crop_or_pad_yield_mask, 
+    soft_append_bcthw, 
+    resize_and_center_crop, 
+    generate_timestamp
+)
 from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
 from diffusers_helper.pipelines.k_diffusion_hunyuan import sample_hunyuan
-from diffusers_helper.memory import cpu, gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation, offload_model_from_device_for_memory_preservation, fake_diffusers_current_device, DynamicSwapInstaller, unload_complete_models, load_model_as_complete, IN_HF_SPACE as MEMORY_IN_HF_SPACE
+from diffusers_helper.memory import (
+    cpu,
+    gpu,
+    get_cuda_free_memory_gb,
+    move_model_to_device_with_memory_preservation,
+    offload_model_from_device_for_memory_preservation,
+    fake_diffusers_current_device,
+    DynamicSwapInstaller,
+    unload_complete_models,
+    load_model_as_complete
+)
 from diffusers_helper.thread_utils import AsyncStream, async_run
 from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html
-from transformers import SiglipImageProcessor, SiglipVisionModel
 from diffusers_helper.clip_vision import hf_clip_vision_encode
-from diffusers_helper.bucket_tools import find_nearest_bucket
 
 outputs_folder = './outputs/'
 os.makedirs(outputs_folder, exist_ok=True)
 
-# Spaces環境では、すべてのCUDA操作を遅延させる
+# Manage GPU memory if not in HF Space
 if not IN_HF_SPACE:
-    # 非Spaces環境でのみCUDAメモリを取得
     try:
         if torch.cuda.is_available():
             free_mem_gb = get_cuda_free_memory_gb(gpu)
-            print(f'空きVRAM {free_mem_gb} GB')
+            print(f'Free VRAM: {free_mem_gb} GB')
         else:
-            free_mem_gb = 6.0  # デフォルト値
-            print("CUDAが利用できません。デフォルトのメモリ設定を使用します")
+            free_mem_gb = 6.0
+            print("CUDA not available, using default memory setting.")
     except Exception as e:
-        free_mem_gb = 6.0  # デフォルト値
-        print(f"CUDAメモリ取得中にエラーが発生しました: {e}、デフォルトのメモリ設定を使用します")
-        
+        free_mem_gb = 6.0
+        print(f"Error getting CUDA memory: {e}, using default=6GB")
     high_vram = free_mem_gb > 60
-    print(f'高VRAM モード: {high_vram}')
+    print(f'High-VRAM mode: {high_vram}')
 else:
-    # Spaces環境ではデフォルト値を使用
-    print("Spaces環境でデフォルトのメモリ設定を使用します")
+    print("Using default memory settings in a HF Space.")
     try:
         if GPU_AVAILABLE:
-            free_mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9 * 0.9  # GPUメモリの90%を使用
-            high_vram = free_mem_gb > 10  # より保守的な条件
+            free_mem_gb = torch.cuda.get_device_properties(0).total_memory / 1e9 * 0.9
+            high_vram = free_mem_gb > 10
         else:
-            free_mem_gb = 6.0  # デフォルト値
+            free_mem_gb = 6.0
             high_vram = False
     except Exception as e:
-        print(f"GPUメモリ取得中にエラーが発生しました: {e}")
-        free_mem_gb = 6.0  # デフォルト値
+        print(f"Error retrieving GPU memory: {e}")
+        free_mem_gb = 6.0
         high_vram = False
-    
-    print(f'GPUメモリ: {free_mem_gb:.2f} GB, 高VRAMモード: {high_vram}')
+    print(f'GPU mem: {free_mem_gb:.2f} GB, high_vram={high_vram}')
 
-# modelsグローバル変数でモデル参照を保存
 models = {}
-cpu_fallback_mode = not GPU_AVAILABLE  # GPUが利用できない場合、CPU代替モードを使用
+cpu_fallback_mode = not GPU_AVAILABLE
+
 
-# モデルロード関数を使用
 def load_models():
+    """
+    Load the entire pipeline models (VAE, text encoders, image encoder, transformer).
+    """
     global models, cpu_fallback_mode, GPU_INITIALIZED
     
     if GPU_INITIALIZED:
-        print("モデルはすでに読み込まれています。重複読み込みをスキップします")
+        print("Models are already loaded. Skipping duplicate loading.")
         return models
     
-    print("モデルの読み込みを開始しています...")
-    
+    print("Starting model load...")
+
     try:
-        # GPU利用可能性に基づいてデバイスを設定
-        device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
-        model_device = 'cpu'  # 初期はCPUに読み込み
-        
-        # メモリ節約のために精度を下げる
+        device = 'cuda' if (GPU_AVAILABLE and not cpu_fallback_mode) else 'cpu'
+        model_device = 'cpu'
+
         dtype = torch.float16 if GPU_AVAILABLE else torch.float32
         transformer_dtype = torch.bfloat16 if GPU_AVAILABLE else torch.float32
-        
-        print(f"使用デバイス: {device}, モデル精度: {dtype}, Transformer精度: {transformer_dtype}")
-        
-        # モデルを読み込み
-        try:
-            text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to(model_device)
-            text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to(model_device)
-            tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
-            tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
-            vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to(model_device)
 
-            feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
-            image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to(model_device)
+        print(f"Device: {device}, VAE/encoders dtype={dtype}, transformer dtype={transformer_dtype}")
 
-            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('tori29umai/FramePackI2V_HY_rotate_landscape', torch_dtype=transformer_dtype).to(model_device)
-            
-            print("すべてのモデルの読み込みに成功しました")
+        try:
+            text_encoder = LlamaModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo", 
+                subfolder='text_encoder', 
+                torch_dtype=dtype
+            ).to(model_device)
+            text_encoder_2 = CLIPTextModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo", 
+                subfolder='text_encoder_2', 
+                torch_dtype=dtype
+            ).to(model_device)
+            tokenizer = LlamaTokenizerFast.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer'
+            )
+            tokenizer_2 = CLIPTokenizer.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer_2'
+            )
+            vae = AutoencoderKLHunyuanVideo.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='vae',
+                torch_dtype=dtype
+            ).to(model_device)
+
+            feature_extractor = SiglipImageProcessor.from_pretrained(
+                "lllyasviel/flux_redux_bfl", 
+                subfolder='feature_extractor'
+            )
+            image_encoder = SiglipVisionModel.from_pretrained(
+                "lllyasviel/flux_redux_bfl",
+                subfolder='image_encoder',
+                torch_dtype=dtype
+            ).to(model_device)
+
+            # Use a custom rotating-landscape model (for example)
+            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
+                "tori29umai/FramePackI2V_HY_rotate_landscape", 
+                torch_dtype=transformer_dtype
+            ).to(model_device)
+
+            print("All models loaded successfully.")
         except Exception as e:
-            print(f"モデル読み込み中にエラーが発生しました: {e}")
-            print("精度を下げて再試行します...")
-            
-            # 精度を下げて再試行
+            print(f"Error loading models: {e}")
+            print("Retry with float32 on CPU.")
             dtype = torch.float32
             transformer_dtype = torch.float32
             cpu_fallback_mode = True
-            
-            text_encoder = LlamaModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder', torch_dtype=dtype).to('cpu')
-            text_encoder_2 = CLIPTextModel.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='text_encoder_2', torch_dtype=dtype).to('cpu')
-            tokenizer = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer')
-            tokenizer_2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='tokenizer_2')
-            vae = AutoencoderKLHunyuanVideo.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder='vae', torch_dtype=dtype).to('cpu')
 
-            feature_extractor = SiglipImageProcessor.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='feature_extractor')
-            image_encoder = SiglipVisionModel.from_pretrained("lllyasviel/flux_redux_bfl", subfolder='image_encoder', torch_dtype=dtype).to('cpu')
+            text_encoder = LlamaModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo", 
+                subfolder='text_encoder', 
+                torch_dtype=dtype
+            ).to('cpu')
+            text_encoder_2 = CLIPTextModel.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo", 
+                subfolder='text_encoder_2', 
+                torch_dtype=dtype
+            ).to('cpu')
+            tokenizer = LlamaTokenizerFast.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer'
+            )
+            tokenizer_2 = CLIPTokenizer.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='tokenizer_2'
+            )
+            vae = AutoencoderKLHunyuanVideo.from_pretrained(
+                "hunyuanvideo-community/HunyuanVideo",
+                subfolder='vae',
+                torch_dtype=dtype
+            ).to('cpu')
+
+            feature_extractor = SiglipImageProcessor.from_pretrained(
+                "lllyasviel/flux_redux_bfl", 
+                subfolder='feature_extractor'
+            )
+            image_encoder = SiglipVisionModel.from_pretrained(
+                "lllyasviel/flux_redux_bfl",
+                subfolder='image_encoder',
+                torch_dtype=dtype
+            ).to('cpu')
 
-            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained('tori29umai/FramePackI2V_HY_rotate_landscape', torch_dtype=transformer_dtype).to('cpu')
-            
-            print("CPUモードですべてのモデルの読み込みに成功しました")
+            transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
+                "tori29umai/FramePackI2V_HY_rotate_landscape", 
+                torch_dtype=transformer_dtype
+            ).to('cpu')
+
+            print("Models loaded in CPU-only fallback mode.")
 
         vae.eval()
         text_encoder.eval()
@@ -177,9 +251,8 @@ def load_models():
             vae.enable_tiling()
 
         transformer.high_quality_fp32_output_for_inference = True
-        print('transformer.high_quality_fp32_output_for_inference = True')
+        print("transformer.high_quality_fp32_output_for_inference = True")
 
-        # モデル精度を設定
         if not cpu_fallback_mode:
             transformer.to(dtype=transformer_dtype)
             vae.to(dtype=dtype)
@@ -196,7 +269,6 @@ def load_models():
         if torch.cuda.is_available() and not cpu_fallback_mode:
             try:
                 if not high_vram:
-                    # DynamicSwapInstallerはhuggingfaceのenable_sequential_offloadと同じですが3倍高速です
                     DynamicSwapInstaller.install_model(transformer, device=device)
                     DynamicSwapInstaller.install_model(text_encoder, device=device)
                 else:
@@ -205,14 +277,13 @@ def load_models():
                     image_encoder.to(device)
                     vae.to(device)
                     transformer.to(device)
-                print(f"モデルを{device}デバイスに移動することに成功しました")
+                print(f"Successfully moved models to {device}")
             except Exception as e:
-                print(f"モデルを{device}に移動中にエラーが発生しました: {e}")
-                print("CPUモードにフォールバックします")
+                print(f"Error moving models to {device}: {e}")
+                print("Falling back to CPU.")
                 cpu_fallback_mode = True
-        
-        # グローバル変数に保存
-        models = {
+
+        models_local = {
             'text_encoder': text_encoder,
             'text_encoder_2': text_encoder_2,
             'tokenizer': tokenizer,
@@ -224,196 +295,168 @@ def load_models():
         }
         
         GPU_INITIALIZED = True
-        print(f"モデルの読み込みが完了しました。実行モード: {'CPU' if cpu_fallback_mode else 'GPU'}")
+        models.update(models_local)
+        print(f"Model load complete. Mode: {'CPU' if cpu_fallback_mode else 'GPU'}")
         return models
     except Exception as e:
-        print(f"モデル読み込みプロセスでエラーが発生しました: {e}")
+        print(f"Unexpected error in load_models(): {e}")
         traceback.print_exc()
-        
-        # より詳細なエラー情報を記録
-        error_info = {
-            "error": str(e),
-            "traceback": traceback.format_exc(),
-            "cuda_available": torch.cuda.is_available(),
-            "device": "cpu" if cpu_fallback_mode else "cuda",
-        }
-        
-        # トラブルシューティングのためにエラー情報をファイルに保存
-        try:
-            with open(os.path.join(outputs_folder, "error_log.txt"), "w") as f:
-                f.write(str(error_info))
-        except:
-            pass
-            
-        # アプリが引き続き実行を試みることができるよう空の辞書を返す
         cpu_fallback_mode = True
         return {}
 
 
-# Hugging Face Spaces GPU装飾子を使用
+# Use GPU decorator if in HF Space
 if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE:
     try:
         @spaces.GPU
         def initialize_models():
-            """@spaces.GPU装飾子内でモデルを初期化"""
             global GPU_INITIALIZED
             try:
                 result = load_models()
                 GPU_INITIALIZED = True
                 return result
             except Exception as e:
-                print(f"spaces.GPUを使用したモデル初期化中にエラーが発生しました: {e}")
-                traceback.print_exc()
+                print(f"Error in @spaces.GPU model init: {e}")
                 global cpu_fallback_mode
                 cpu_fallback_mode = True
-                # 装飾子を使わずに再試行
                 return load_models()
     except Exception as e:
-        print(f"spaces.GPU装飾子の作成中にエラーが発生しました: {e}")
-        # 装飾子がエラーの場合、非装飾子版を直接使用
+        print(f"Error creating spaces.GPU decorator: {e}")
         def initialize_models():
             return load_models()
+else:
+    def initialize_models():
+        return load_models()
 
 
-# 以下の関数内部でモデルの取得を遅延させる
 def get_models():
-    """モデルを取得し、まだ読み込まれていない場合は読み込む"""
-    global models, GPU_INITIALIZED
-    
-    # 並行読み込みを防ぐためのモデル読み込みロックを追加
+    """
+    Retrieve the global models or load them if not yet loaded.
+    """
+    global models
     model_loading_key = "__model_loading__"
-    
+
     if not models:
-        # モデルが読み込み中かチェック
         if model_loading_key in globals():
-            print("モデルは現在読み込み中です。お待ちください...")
-            # モデル読み込み完了を待機
+            print("Models are loading. Please wait.")
             import time
-            start_wait = time.time()
-            while not models and model_loading_key in globals():
+            start_time = time.time()
+            while (not models) and (model_loading_key in globals()):
                 time.sleep(0.5)
-                # 60秒以上待機したら読み込み失敗と判断
-                if time.time() - start_wait > 60:
-                    print("モデル読み込み待機がタイムアウトしました")
+                if time.time() - start_time > 60:
+                    print("Timed out waiting for model load.")
                     break
-            
             if models:
                 return models
-            
         try:
-            # 読み込みフラグを設定
             globals()[model_loading_key] = True
-            
             if IN_HF_SPACE and 'spaces' in globals() and GPU_AVAILABLE and not cpu_fallback_mode:
                 try:
-                    print("@spaces.GPU装飾子を使用してモデルを読み込みます")
-                    models = initialize_models()
+                    print("Loading models via @spaces.GPU")
+                    models_local = initialize_models()
+                    models.update(models_local)
                 except Exception as e:
-                    print(f"GPU装飾子を使用したモデル読み込みに失敗しました: {e}")
-                    print("直接モデルを読み込みます")
-                    models = load_models()
+                    print(f"GPU decorator load error: {e}, fallback to direct load.")
+                    models_local = load_models()
+                    models.update(models_local)
             else:
-                print("モデルを直接読み込みます")
-                models = load_models()
+                models_local = load_models()
+                models.update(models_local)
         except Exception as e:
-            print(f"モデル読み込み中に予期しないエラーが発生しました: {e}")
-            traceback.print_exc()
-            # 空の辞書を確保
-            models = {}
+            print(f"Unexpected error while loading models: {e}")
+            models.clear()
         finally:
-            # 成功か失敗にかかわらず、読み込みフラグを削除
             if model_loading_key in globals():
                 del globals()[model_loading_key]
-    
     return models
 
 
-# 事前定義された解像度リスト（グローバル変数として追加）
+# Predefined resolutions for a rotating-landscape scenario
 PREDEFINED_RESOLUTIONS = [
     (416, 960), (448, 864), (480, 832), (512, 768), (544, 704), 
     (576, 672), (608, 640), (640, 608), (672, 576), (704, 544), 
     (768, 512), (832, 480), (864, 448), (960, 416)
 ]
 
-# 最も近いアスペクト比を見つける関数
 def find_closest_aspect_ratio(width, height, target_resolutions):
     """
-    事前定義された解像度リストから、元の画像のアスペクト比に最も近い解像度を見つける
-    
-    引数:
-        width: 元の画像の幅
-        height: 元の画像の高さ
-        target_resolutions: 目標解像度のリスト（幅, 高さ）のタプル
-        
-    戻り値:
-        tuple: 最も近いアスペクト比の (target_width, target_height)
+    Find the resolution in 'target_resolutions' whose aspect ratio
+    is closest to the original image aspect ratio (width/height).
     """
     original_aspect = width / height
-    
-    # 各目標解像度に対してアスペクト比の差を計算
     min_diff = float('inf')
     closest_resolution = None
     
-    for target_width, target_height in target_resolutions:
-        target_aspect = target_width / target_height
+    for tw, th in target_resolutions:
+        target_aspect = tw / th
         diff = abs(original_aspect - target_aspect)
-        
         if diff < min_diff:
             min_diff = diff
-            closest_resolution = (target_width, target_height)
-    
+            closest_resolution = (tw, th)
     return closest_resolution
 
 
 stream = AsyncStream()
 
-
 @torch.no_grad()
-def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache):
+def worker(
+    input_image, 
+    prompt, 
+    n_prompt, 
+    seed, 
+    total_second_length, 
+    latent_window_size, 
+    steps, 
+    cfg, 
+    gs, 
+    rs, 
+    gpu_memory_preservation, 
+    use_teacache
+):
+    """
+    Background worker that performs the actual generation.
+    """
     global last_update_time
     last_update_time = time.time()
-    
-    # 動画の長さを5秒以下に制限
+
+    # For demonstration, limit max length to 3 seconds
     total_second_length = min(total_second_length, 3.0)
     
-    # モデルを取得
     try:
-        models = get_models()
-        if not models:
-            error_msg = "モデルの読み込みに失敗しました。詳細情報はログを確認してください"
-            print(error_msg)
-            stream.output_queue.push(('error', error_msg))
+        models_local = get_models()
+        if not models_local:
+            err_msg = "Failed to load models. Check logs for details."
+            print(err_msg)
+            stream.output_queue.push(('error', err_msg))
             stream.output_queue.push(('end', None))
             return
         
-        text_encoder = models['text_encoder']
-        text_encoder_2 = models['text_encoder_2']
-        tokenizer = models['tokenizer']
-        tokenizer_2 = models['tokenizer_2']
-        vae = models['vae']
-        feature_extractor = models['feature_extractor']
-        image_encoder = models['image_encoder']
-        transformer = models['transformer']
+        text_encoder = models_local['text_encoder']
+        text_encoder_2 = models_local['text_encoder_2']
+        tokenizer = models_local['tokenizer']
+        tokenizer_2 = models_local['tokenizer_2']
+        vae = models_local['vae']
+        feature_extractor = models_local['feature_extractor']
+        image_encoder = models_local['image_encoder']
+        transformer = models_local['transformer']
     except Exception as e:
-        error_msg = f"モデル取得中にエラーが発生しました: {e}"
-        print(error_msg)
+        err = f"Error retrieving models: {e}"
+        print(err)
         traceback.print_exc()
-        stream.output_queue.push(('error', error_msg))
+        stream.output_queue.push(('error', err))
         stream.output_queue.push(('end', None))
         return
-    
-    # デバイスを決定
-    device = 'cuda' if GPU_AVAILABLE and not cpu_fallback_mode else 'cpu'
-    print(f"推論に使用するデバイス: {device}")
-    
-    # CPUモードに合わせてパラメータを調整
+
+    device = 'cuda' if (GPU_AVAILABLE and not cpu_fallback_mode) else 'cpu'
+    print(f"Inference device: {device}")
+
+    # Adjust parameters if in CPU fallback
     if cpu_fallback_mode:
-        print("CPUモードではより軽量なパラメータを使用します")
-        # CPU処理を高速化するために処理サイズを小さくする
+        print("CPU fallback mode: using smaller parameters for performance.")
         latent_window_size = min(latent_window_size, 5)
-        steps = min(steps, 15)  # ステップ数を減らす
-        total_second_length = min(total_second_length, 2.0)  # CPUモードでは動画の長さをさらに制限
-    
+        steps = min(steps, 15)
+        total_second_length = min(total_second_length, 2.0)
+
     total_latent_sections = (total_second_length * 30) / (latent_window_size * 4)
     total_latent_sections = int(max(round(total_latent_sections), 1))
 
@@ -423,22 +466,20 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
     history_latents = None
     total_generated_latent_frames = 0
 
-    stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, '開始中 ...'))))
+    stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting ...'))))
 
     try:
-        # GPUをクリーン
         if not high_vram and not cpu_fallback_mode:
             try:
                 unload_complete_models(
                     text_encoder, text_encoder_2, image_encoder, vae, transformer
                 )
             except Exception as e:
-                print(f"モデルのアンロード中にエラーが発生しました: {e}")
-                # 処理を中断せずに続行
+                print(f"Error unloading models: {e}")
 
-        # テキストエンコーディング
+        # Text encode
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'テキストエンコーディング中 ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Encoding text ...'))))
 
         try:
             if not high_vram and not cpu_fallback_mode:
@@ -446,7 +487,6 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
                 load_model_as_complete(text_encoder_2, target_device=device)
 
             llama_vec, clip_l_pooler = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
-
             if cfg == 1:
                 llama_vec_n, clip_l_pooler_n = torch.zeros_like(llama_vec), torch.zeros_like(clip_l_pooler)
             else:
@@ -455,85 +495,72 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             llama_vec, llama_attention_mask = crop_or_pad_yield_mask(llama_vec, length=512)
             llama_vec_n, llama_attention_mask_n = crop_or_pad_yield_mask(llama_vec_n, length=512)
         except Exception as e:
-            error_msg = f"テキストエンコーディング中にエラーが発生しました: {e}"
-            print(error_msg)
+            err = f"Text encoding error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # 入��画像の処理
+        # Process input image
         try:
             H, W, C = input_image.shape
+            target_w, target_h = find_closest_aspect_ratio(W, H, PREDEFINED_RESOLUTIONS)
             
-            # 事前定義された解像度から最も近いアスペクト比を見つける
-            target_width, target_height = find_closest_aspect_ratio(W, H, PREDEFINED_RESOLUTIONS)
-            
-            # height, width変数も保持する（元のコードとの互換性のため）
-            width = target_width
-            height = target_height
-            
-            # CPUモードの場合、処理サイズを小さくする
+            # If CPU fallback, scale down
             if cpu_fallback_mode:
-                scale_factor = min(320 / target_height, 320 / target_width)
-                target_height = int(target_height * scale_factor)
-                target_width = int(target_width * scale_factor)
-                # 縮小後の値も更新
-                height = target_height
-                width = target_width
-                
-            print(f'元の画像サイズ: {W}x{H}, リサイズ先: {target_width}x{target_height}')
+                scale_factor = min(320 / target_h, 320 / target_w)
+                target_h = int(target_h * scale_factor)
+                target_w = int(target_w * scale_factor)
             
-            # 選択された解像度にリサイズ
-            input_image_np = resize_and_center_crop(input_image, target_width=target_width, target_height=target_height)
+            print(f"Original image: {W}x{H}, resizing to: {target_w}x{target_h}")
+            input_image_np = resize_and_center_crop(input_image, target_width=target_w, target_height=target_h)
             Image.fromarray(input_image_np).save(os.path.join(outputs_folder, f'{job_id}.png'))
 
             input_image_pt = torch.from_numpy(input_image_np).float() / 127.5 - 1
             input_image_pt = input_image_pt.permute(2, 0, 1)[None, :, None]
         except Exception as e:
-            error_msg = f"画像処理中にエラーが発生しました: {e}"
-            print(error_msg)
+            err = f"Image processing error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # VAEエンコーディング
+        # VAE encode
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAEエンコーディング中 ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'VAE encoding ...'))))
 
         try:
             if not high_vram and not cpu_fallback_mode:
                 load_model_as_complete(vae, target_device=device)
-
             start_latent = vae_encode(input_image_pt, vae)
         except Exception as e:
-            error_msg = f"VAEエンコーディング中にエラーが発生しました: {e}"
-            print(error_msg)
+            err = f"VAE encode error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
         # CLIP Vision
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Visionエンコーディング中 ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'CLIP Vision encoding ...'))))
 
         try:
             if not high_vram and not cpu_fallback_mode:
                 load_model_as_complete(image_encoder, target_device=device)
-
             image_encoder_output = hf_clip_vision_encode(input_image_np, feature_extractor, image_encoder)
             image_encoder_last_hidden_state = image_encoder_output.last_hidden_state
         except Exception as e:
-            error_msg = f"CLIP Visionエンコーディング中にエラーが発生しました: {e}"
-            print(error_msg)
+            err = f"CLIP Vision encode error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # データ型
+        # Convert dtype
         try:
             llama_vec = llama_vec.to(transformer.dtype)
             llama_vec_n = llama_vec_n.to(transformer.dtype)
@@ -541,75 +568,76 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             clip_l_pooler_n = clip_l_pooler_n.to(transformer.dtype)
             image_encoder_last_hidden_state = image_encoder_last_hidden_state.to(transformer.dtype)
         except Exception as e:
-            error_msg = f"データ型変換中にエ���ーが発生しました: {e}"
-            print(error_msg)
+            err = f"Data type conversion error: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        # サンプリング
+        # Sampling
         last_update_time = time.time()
-        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'サンプリング開始 ...'))))
+        stream.output_queue.push(('progress', (None, '', make_progress_bar_html(0, 'Starting sampling...'))))
 
         rnd = torch.Generator("cpu").manual_seed(seed)
         num_frames = latent_window_size * 4 - 3
 
         try:
-            history_latents = torch.zeros(size=(1, 16, 1 + 2 + 16, height // 8, width // 8), dtype=torch.float32).cpu()
+            history_latents = torch.zeros(
+                size=(1, 16, 1 + 2 + 16, target_h // 8, target_w // 8), 
+                dtype=torch.float32
+            ).cpu()
             history_pixels = None
             total_generated_latent_frames = 0
         except Exception as e:
-            error_msg = f"履歴状態の初期化中にエラーが発生しました: {e}"
-            print(error_msg)
+            err = f"Error initializing history latents: {e}"
+            print(err)
             traceback.print_exc()
-            stream.output_queue.push(('error', error_msg))
+            stream.output_queue.push(('error', err))
             stream.output_queue.push(('end', None))
             return
 
-        latent_paddings = reversed(range(total_latent_sections))
-
+        latent_paddings = list(reversed(range(total_latent_sections)))
         if total_latent_sections > 4:
-            # 理論的にはlatent_paddingsは上記のシーケンスに従うべきですが、
-            # total_latent_sections > 4の場合、展開するよりもいくつかの項目を複製する方が
-            # 良い結果になるようです
-            # 比較するために、latent_paddings = list(reversed(range(total_latent_sections)))を
-            # 使用して下記のトリックを削除することもできます
-            latent_paddings = [3] + [2] * (total_latent_sections - 3) + [1, 0]
+            latent_paddings = [3] + [2]*(total_latent_sections - 3) + [1, 0]
 
         for latent_padding in latent_paddings:
             last_update_time = time.time()
-            is_last_section = latent_padding == 0
+            is_last_section = (latent_padding == 0)
             latent_padding_size = latent_padding * latent_window_size
 
             if stream.input_queue.top() == 'end':
-                # 終了時に現在の動画を保存することを確認
                 if history_pixels is not None and total_generated_latent_frames > 0:
                     try:
-                        output_filename = os.path.join(outputs_folder, f'{job_id}_final_{total_generated_latent_frames}.mp4')
-                        save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=18)
-                        stream.output_queue.push(('file', output_filename))
+                        final_name = os.path.join(outputs_folder, f'{job_id}_final_{total_generated_latent_frames}.mp4')
+                        save_bcthw_as_mp4(history_pixels, final_name, fps=30, crf=18)
+                        stream.output_queue.push(('file', final_name))
                     except Exception as e:
-                        print(f"最終動画保存中にエラーが発生しました: {e}")
-                
+                        print(f"Error saving final partial video: {e}")
                 stream.output_queue.push(('end', None))
                 return
 
-            print(f'latent_padding_size = {latent_padding_size}, is_last_section = {is_last_section}')
+            print(f'latent_padding_size = {latent_padding_size}, is_last_section={is_last_section}')
 
             try:
                 indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)
-                clean_latent_indices_pre, blank_indices, latent_indices, clean_latent_indices_post, clean_latent_2x_indices, clean_latent_4x_indices = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
-                clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)
+                (
+                    cidx_pre,
+                    blank_indices,
+                    latent_indices,
+                    cidx_post,
+                    cidx_2x,
+                    cidx_4x
+                ) = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
+                clean_latent_indices = torch.cat([cidx_pre, cidx_post], dim=1)
 
                 clean_latents_pre = start_latent.to(history_latents)
-                clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, :1 + 2 + 16, :, :].split([1, 2, 16], dim=2)
-                clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)
+                c_latents_post, c_latents_2x, c_latents_4x = history_latents[:, :, :1 + 2 + 16].split([1, 2, 16], dim=2)
+                clean_latents = torch.cat([clean_latents_pre, c_latents_post], dim=2)
             except Exception as e:
-                error_msg = f"サンプリングデータ準備中にエラーが発生しました: {e}"
-                print(error_msg)
+                err = f"Error preparing sampling data: {e}"
+                print(err)
                 traceback.print_exc()
-                # 完全に終了せずに次のイテレーションを試みる
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
                 continue
@@ -617,17 +645,17 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             if not high_vram and not cpu_fallback_mode:
                 try:
                     unload_complete_models()
-                    move_model_to_device_with_memory_preservation(transformer, target_device=device, preserved_memory_gb=gpu_memory_preservation)
+                    move_model_to_device_with_memory_preservation(
+                        transformer, target_device=device, preserved_memory_gb=gpu_memory_preservation
+                    )
                 except Exception as e:
-                    print(f"transformerをGPUに移動中にエラーが発生しました: {e}")
-                    # パフォーマンスに影響する可能性はありますが、終了する必要はないので続行
+                    print(f"Error moving transformer to GPU: {e}")
 
             if use_teacache and not cpu_fallback_mode:
                 try:
                     transformer.initialize_teacache(enable_teacache=True, num_steps=steps)
                 except Exception as e:
-                    print(f"teacache初期化中にエラーが発生しました: {e}")
-                    # teacacheを無効にして続行
+                    print(f"Error initializing TeaCache: {e}")
                     transformer.initialize_teacache(enable_teacache=False)
             else:
                 transformer.initialize_teacache(enable_teacache=False)
@@ -635,65 +663,39 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
             def callback(d):
                 global last_update_time
                 last_update_time = time.time()
-                
                 try:
-                    # まず停止信号があるかチェック
-                    print(f"【デバッグ】コールバック関数: ステップ {d['i']}, 停止信号のチェック")
-                    try:
-                        queue_top = stream.input_queue.top()
-                        print(f"【デバッグ】コールバック関数: キュー先頭信号 = {queue_top}")
-                        
-                        if queue_top == 'end':
-                            print("【デバッグ】コールバック関数: 停止信号を検出、中断準備中...")
-                            try:
-                                stream.output_queue.push(('end', None))
-                                print("【デバッグ】コールバック関数: 出力キューにend信号を正常に送信")
-                            except Exception as e:
-                                print(f"【デバッグ】コールバック関数: 出力キューにend信号送信中にエラー: {e}")
-                                
-                            print("【デバッグ】コールバック関数: KeyboardInterrupt例外を投げる準備")
-                            raise KeyboardInterrupt('ユーザーによるタスク停止')
-                    except Exception as e:
-                        print(f"【デバッグ】コールバック関数: キュー先頭信号チェック中にエラー: {e}")
-                        
-                    preview = d['denoised']
-                    preview = vae_decode_fake(preview)
-
-                    preview = (preview * 255.0).detach().cpu().numpy().clip(0, 255).astype(np.uint8)
-                    preview = einops.rearrange(preview, 'b c t h w -> (b h) (t w) c')
-
-                    current_step = d['i'] + 1
-                    percentage = int(100.0 * current_step / steps)
-                    hint = f'サンプリング中 {current_step}/{steps}'
-                    desc = f'総生成フレーム数: {int(max(0, total_generated_latent_frames * 4 - 3))}, 動画長: {max(0, (total_generated_latent_frames * 4 - 3) / 30) :.2f} 秒 (FPS-30). 動画を現在拡張中...'
-                    stream.output_queue.push(('progress', (preview, desc, make_progress_bar_html(percentage, hint))))
-                except KeyboardInterrupt as e:
-                    # 中断例外をキャッチして再スローし、サンプリング関数に伝播されるようにする
-                    print(f"【デバッグ】コールバック関数: KeyboardInterruptをキャッチ: {e}")
-                    print("【デバッグ】コールバック関数: 中断例外を再スロー、サンプリング関数に伝播")
+                    if stream.input_queue.top() == 'end':
+                        stream.output_queue.push(('end', None))
+                        raise KeyboardInterrupt('User requested stop.')
+                    preview_latents = d['denoised']
+                    preview_latents = vae_decode_fake(preview_latents)
+                    preview_img = (preview_latents * 255.0).cpu().numpy().clip(0,255).astype(np.uint8)
+                    preview_img = einops.rearrange(preview_img, 'b c t h w -> (b h) (t w) c')
+
+                    curr_step = d['i'] + 1
+                    percentage = int(100.0 * curr_step / steps)
+                    hint = f'Sampling {curr_step}/{steps}'
+                    desc = f'Generated frames so far: {int(max(0, total_generated_latent_frames * 4 - 3))}'
+                    bar_html = make_progress_bar_html(percentage, hint)
+                    stream.output_queue.push(('progress', (preview_img, desc, bar_html)))
+                except KeyboardInterrupt:
                     raise
-                except Exception as e:
-                    print(f"【デバッグ】コールバック関数でエラー: {e}")
-                    # サンプリングプロセスを中断しない
-                print(f"【デバッグ】コールバック関数: ステップ {d['i']} 完了")
+                except Exception as exc:
+                    print(f"Error in sampling callback: {exc}")
                 return
 
             try:
-                sampling_start_time = time.time()
-                print(f"サンプリング開始、デバイス: {device}, データ型: {transformer.dtype}, TeaCache使用: {use_teacache and not cpu_fallback_mode}")
-                
+                print(f"Sampling: device={device}, dtype={transformer.dtype}, teacache={use_teacache}")
                 try:
-                    print("【デバッグ】sample_hunyuanサンプリングプロセス開始")
                     generated_latents = sample_hunyuan(
                         transformer=transformer,
                         sampler='unipc',
-                        width=width,
-                        height=height,
+                        width=target_w,
+                        height=target_h,
                         frames=num_frames,
                         real_guidance_scale=cfg,
                         distilled_guidance_scale=gs,
                         guidance_rescale=rs,
-                        # shift=3.0,
                         num_inference_steps=steps,
                         generator=rnd,
                         prompt_embeds=llama_vec,
@@ -708,181 +710,119 @@ def worker(input_image, prompt, n_prompt, seed, total_second_length, latent_wind
                         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,
+                        clean_latents_2x=c_latents_2x,
+                        clean_latent_2x_indices=cidx_2x,
+                        clean_latents_4x=c_latents_4x,
+                        clean_latent_4x_indices=cidx_4x,
+                        callback=callback
                     )
-                    
-                    print(f"【デバッグ】サンプリング完了、所要時間: {time.time() - sampling_start_time:.2f}秒")
                 except KeyboardInterrupt as e:
-                    # ユーザーによる中断
-                    print(f"【デバッグ】KeyboardInterruptをキャッチ: {e}")
-                    print("【デバッグ】ユーザーによるサンプリングプロセス中断、中断ロジック処理中")
-                    
-                    # 既に生成された動画がある場合、最後に生成された動画を返す
+                    print(f"User interrupt: {e}")
                     if last_output_filename:
-                        print(f"【デバッグ】部分的に生成された動画あり: {last_output_filename}、この動画を返します")
                         stream.output_queue.push(('file', last_output_filename))
-                        error_msg = "ユーザーにより生成プロセスが中断されましたが、部分的な動画は生成されています"
+                        err_msg = "User stopped generation; partial video returned."
                     else:
-                        print("【デバッグ】部分的に生成された動画なし、中断メッセージを返します")
-                        error_msg = "ユーザーにより生成プロセスが中断され、動画は生成されていません"
-                    
-                    print(f"【デバッグ】エラーメッセージを送信: {error_msg}")
-                    stream.output_queue.push(('error', error_msg))
-                    print("【デバッグ】end信号を送信")
+                        err_msg = "User stopped generation; no video produced."
+                    stream.output_queue.push(('error', err_msg))
                     stream.output_queue.push(('end', None))
-                    print("【デバッグ】中断処理完了、リターン")
                     return
             except Exception as e:
-                print(f"サンプリングプロセス中にエラーが発生しました: {e}")
+                print(f"Error during sampling: {e}")
                 traceback.print_exc()
-                
-                # 既に生成された動画がある場合、最後に生成された動画を返す
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
-                    
-                    # エラーメッセージを作成
-                    error_msg = f"サンプリングプロセス中にエラーが発生しましたが、部分的に生成された動画を返します: {e}"
-                    stream.output_queue.push(('error', error_msg))
+                    err_msg = f"Sampling error; partial video returned: {e}"
+                    stream.output_queue.push(('error', err_msg))
                 else:
-                    # 生成された動画がない場合、エラーメッセージを返す
-                    error_msg = f"サンプリングプロセス中にエラーが発生し、動画を生成できませんでした: {e}"
-                    stream.output_queue.push(('error', error_msg))
-                
+                    err_msg = f"Sampling error; no video produced: {e}"
+                    stream.output_queue.push(('error', err_msg))
                 stream.output_queue.push(('end', None))
                 return
 
             try:
                 if is_last_section:
                     generated_latents = torch.cat([start_latent.to(generated_latents), generated_latents], dim=2)
-
                 total_generated_latent_frames += int(generated_latents.shape[2])
                 history_latents = torch.cat([generated_latents.to(history_latents), history_latents], dim=2)
             except Exception as e:
-                error_msg = f"生成された潜在変数の処理中にエラーが発生しました: {e}"
-                print(error_msg)
+                err = f"Error merging latent outputs: {e}"
+                print(err)
                 traceback.print_exc()
-                
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
-                stream.output_queue.push(('error', error_msg))
+                stream.output_queue.push(('error', err))
                 stream.output_queue.push(('end', None))
                 return
 
             if not high_vram and not cpu_fallback_mode:
                 try:
-                    offload_model_from_device_for_memory_preservation(transformer, target_device=device, preserved_memory_gb=8)
+                    offload_model_from_device_for_memory_preservation(
+                        transformer, target_device=device, preserved_memory_gb=8
+                    )
                     load_model_as_complete(vae, target_device=device)
                 except Exception as e:
-                    print(f"モデルメモリ管理中にエラーが発生しました: {e}")
-                    # 続行
+                    print(f"Error managing model memory: {e}")
 
             try:
-                real_history_latents = history_latents[:, :, :total_generated_latent_frames, :, :]
+                real_history_latents = history_latents[:, :, :total_generated_latent_frames]
             except Exception as e:
-                error_msg = f"履歴潜在変数の処理中にエラーが発生しました: {e}"
-                print(error_msg)
-                
+                err = f"Error slicing latents history: {e}"
+                print(err)
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
                 continue
 
             try:
-                vae_start_time = time.time()
-                print(f"VAEデコード開始、潜在変数形状: {real_history_latents.shape}")
-                
                 if history_pixels is None:
                     history_pixels = vae_decode(real_history_latents, vae).cpu()
                 else:
                     section_latent_frames = (latent_window_size * 2 + 1) if is_last_section else (latent_window_size * 2)
                     overlapped_frames = latent_window_size * 4 - 3
-
                     current_pixels = vae_decode(real_history_latents[:, :, :section_latent_frames], vae).cpu()
                     history_pixels = soft_append_bcthw(current_pixels, history_pixels, overlapped_frames)
 
-                print(f"VAEデコード完了、所要時間: {time.time() - vae_start_time:.2f}秒")
-                
-                if not high_vram and not cpu_fallback_mode:
-                    try:
-                        unload_complete_models()
-                    except Exception as e:
-                        print(f"モデルのアンロード中にエラーが発生しました: {e}")
-
                 output_filename = os.path.join(outputs_folder, f'{job_id}_{total_generated_latent_frames}.mp4')
-
-                save_start_time = time.time()
                 save_bcthw_as_mp4(history_pixels, output_filename, fps=30, crf=18)
-                print(f"動画保存完了、所要時間: {time.time() - save_start_time:.2f}秒")
-
-                print(f'デコード完了。現在の潜在変数形状 {real_history_latents.shape}; ピクセル形状 {history_pixels.shape}')
-
                 last_output_filename = output_filename
                 stream.output_queue.push(('file', output_filename))
             except Exception as e:
-                print(f"動画のデコードまたは保存中にエラーが発生しました: {e}")
+                print(f"Error decoding/saving video: {e}")
                 traceback.print_exc()
-                
-                # 既に生成された動画がある場合、最後に生成された動画を返す
                 if last_output_filename:
                     stream.output_queue.push(('file', last_output_filename))
-                
-                # エラー情報を記録
-                error_msg = f"動画のデコードまたは保存中にエラーが発生しました: {e}"
-                stream.output_queue.push(('error', error_msg))
-                
-                # 次のイテレーションを試みる
+                err = f"Error decoding/saving video: {e}"
+                stream.output_queue.push(('error', err))
                 continue
 
             if is_last_section:
                 break
     except Exception as e:
-        print(f"【デバッグ】処理中にエラーが発生しました: {e}, タイプ: {type(e)}")
-        print(f"【デバッグ】エラー詳細:")
+        print(f"Outer error: {e}, type={type(e)}")
         traceback.print_exc()
-        
-        # 中断型例外かチェック
-        if isinstance(e, KeyboardInterrupt):
-            print("【デバッグ】外部KeyboardInterrupt例外を検出")
-
         if not high_vram and not cpu_fallback_mode:
             try:
-                print("【デバッグ】リソース解放のためモデルをアンロード")
                 unload_complete_models(
                     text_encoder, text_encoder_2, image_encoder, vae, transformer
                 )
-                print("【デバッグ】モデルのアンロードに成功")
-            except Exception as unload_error:
-                print(f"【デバッグ】モデルのアンロード中にエラー: {unload_error}")
-                pass
-        
-        # 既に生成された動画がある場合、最後に生成された動画を返す
+            except Exception as ue:
+                print(f"Unload error: {ue}")
         if last_output_filename:
-            print(f"【デバッグ】外部例外処理: 生成済み部分動画を返す {last_output_filename}")
             stream.output_queue.push(('file', last_output_filename))
-        else:
-            print("【デバッグ】外部例外処理: 生成済み動画が見つかりません")
-        
-        # エラーメッセージを返す
-        error_msg = f"処理中にエラーが発生しました: {e}"
-        print(f"【デバッグ】外部例外処理: エラーメッセージを送信: {error_msg}")
-        stream.output_queue.push(('error', error_msg))
+        err = f"Error in worker: {e}"
+        stream.output_queue.push(('error', err))
 
-    # 常にend信号を返すことを確認
-    print("【デバッグ】ワーカー関数終了、end信号を送信")
+    print("Worker finished, pushing end.")
     stream.output_queue.push(('end', None))
-    return
 
 
-# Hugging Face Spaces GPU装飾子を使用してプロセス関数を処理
+# Create a processing function with or without the HF Spaces GPU decorator
 if IN_HF_SPACE and 'spaces' in globals():
     @spaces.GPU
     def process_with_gpu(input_image, prompt, n_prompt, seed, total_second_length, use_teacache):
         global stream
-        assert input_image is not None, '入力画像がありません！'
+        assert input_image is not None, "No input image provided."
 
+        # Fix certain parameters for simplicity
         latent_window_size = 9
         steps = 25
         cfg = 1.0
@@ -890,79 +830,60 @@ if IN_HF_SPACE and 'spaces' in globals():
         rs = 0.0
         gpu_memory_preservation = 6
 
-
-        # UI状態の初期化
         yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
-
         try:
             stream = AsyncStream()
-
-            # ワーカーを非同期で起動
-            async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)
+            async_run(
+                worker,
+                input_image, prompt, n_prompt, seed,
+                total_second_length, latent_window_size, steps,
+                cfg, gs, rs, gpu_memory_preservation, use_teacache
+            )
 
             output_filename = None
             prev_output_filename = None
             error_message = None
 
-            # ワーカーの出力を継続的にチェック
             while True:
                 try:
                     flag, data = stream.output_queue.next()
-
                     if flag == 'file':
                         output_filename = data
                         prev_output_filename = output_filename
-                        # ファイル成功時にエラー表示をクリア
                         yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)
-
-                    if flag == 'progress':
+                    elif flag == 'progress':
                         preview, desc, html = data
-                        # 進捗更新時にエラーメッセージを変更せず、停止ボタンがインタラクティブであることを確認
                         yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
-                    
-                    if flag == 'error':
+                    elif flag == 'error':
                         error_message = data
-                        print(f"エラーメッセージを受信: {error_message}")
-                        # 即時表示せず、end信号を待機
-
-                    if flag == 'end':
-                        # 最後の動画ファイルがある場合、確実に返す
+                        print(f"Received error: {error_message}")
+                    elif flag == 'end':
                         if output_filename is None and prev_output_filename is not None:
                             output_filename = prev_output_filename
-                        
-                        # エラーメッセージがある場合、わかりやすいエラー表示を作成
                         if error_message:
                             yield output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                         else:
-                            # 成功時にエラー表示をしない
                             yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
                         break
                 except Exception as e:
-                    print(f"出力処理中にエラーが発生しました: {e}")
-                    # 長時間更新がないか確認
-                    current_time = time.time()
-                    if current_time - last_update_time > 60:  # 60秒間更新がない場合、処理がフリーズした可能性
-                        print(f"処理がフリーズした可能性があります。{current_time - last_update_time:.1f}秒間更新がありません")
-                        
-                        # 部分的に生成された動画がある場合、それを返す
+                    print(f"Error processing output: {e}")
+                    if (time.time() - last_update_time) > 60:
+                        print(f"No updates for {(time.time()-last_update_time):.1f}s, likely hung.")
                         if prev_output_filename:
                             yield prev_output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                         else:
                             yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                         break
-                    
         except Exception as e:
-            print(f"処理の開始中にエラーが発生しました: {e}")
+            print(f"Error starting process: {e}")
             traceback.print_exc()
-            error_msg = str(e)
-            
             yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
     
     process = process_with_gpu
 else:
     def process(input_image, prompt, n_prompt, seed, total_second_length, use_teacache):
         global stream
-        assert input_image is not None, '入力画像がありません！'
+        assert input_image is not None, "No input image provided."
 
         latent_window_size = 9
         steps = 25
@@ -971,373 +892,252 @@ else:
         rs = 0.0
         gpu_memory_preservation = 6
 
-        # UI状態の初期化
         yield None, None, '', '', gr.update(interactive=False), gr.update(interactive=True)
-
         try:
             stream = AsyncStream()
-
-            # ワーカーを非同期で起動
-            async_run(worker, input_image, prompt, n_prompt, seed, total_second_length, latent_window_size, steps, cfg, gs, rs, gpu_memory_preservation, use_teacache)
+            async_run(
+                worker,
+                input_image, prompt, n_prompt, seed,
+                total_second_length, latent_window_size, steps,
+                cfg, gs, rs, gpu_memory_preservation, use_teacache
+            )
 
             output_filename = None
             prev_output_filename = None
             error_message = None
 
-            # ワーカーの出力を継続的にチェック
             while True:
                 try:
                     flag, data = stream.output_queue.next()
-
                     if flag == 'file':
                         output_filename = data
                         prev_output_filename = output_filename
-                        # ファイル成功時にエラー表示をクリア
                         yield output_filename, gr.update(), gr.update(), '', gr.update(interactive=False), gr.update(interactive=True)
-
-                    if flag == 'progress':
+                    elif flag == 'progress':
                         preview, desc, html = data
-                        # 進捗更新時にエラーメッセージを変更せず、停止ボタンがインタラクティブであることを確認
                         yield gr.update(), gr.update(visible=True, value=preview), desc, html, gr.update(interactive=False), gr.update(interactive=True)
-                    
-                    if flag == 'error':
+                    elif flag == 'error':
                         error_message = data
-                        print(f"エラーメッセージを受信: {error_message}")
-                        # 即時表示せず、end信号を待機
-
-                    if flag == 'end':
-                        # 最後の動画ファイルがある場合、確実に返す
+                        print(f"Received error: {error_message}")
+                    elif flag == 'end':
                         if output_filename is None and prev_output_filename is not None:
                             output_filename = prev_output_filename
-                        
-                        # エラーメッセージがある場合、わかりやすいエラー表示を作成
                         if error_message:
                             yield output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                         else:
-                            # 成功時にエラー表示をしない
                             yield output_filename, gr.update(visible=False), gr.update(), '', gr.update(interactive=True), gr.update(interactive=False)
                         break
                 except Exception as e:
-                    print(f"出力処理中にエラーが発生しました: {e}")
-                    # 長時間更新がないか確認
-                    current_time = time.time()
-                    if current_time - last_update_time > 60:  # 60秒間更新がない場合、処理がフリーズした可能性
-                        print(f"処理がフリーズした可能性があります。{current_time - last_update_time:.1f}秒間更新がありません")
-                        
-                        # 部分的に生成された動画がある場合、それを返す
+                    print(f"Error processing output: {e}")
+                    if (time.time() - last_update_time) > 60:
+                        print(f"No updates for {(time.time()-last_update_time):.1f}s, likely hung.")
                         if prev_output_filename:
                             yield prev_output_filename, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                         else:
                             yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
                         break
-                    
         except Exception as e:
-            print(f"処理の開始中にエラーが発生しました: {e}")
+            print(f"Error starting process: {e}")
             traceback.print_exc()
-            error_msg = str(e)
-            
             yield None, gr.update(visible=False), gr.update(), gr.update(interactive=True), gr.update(interactive=False)
-    
+
 
 def end_process():
-    """生成プロセスを停止する関数 - キューに'end'信号を送信して生成を中断します"""
-    print("【デバッグ】ユーザーが停止ボタンをクリックしました。停止信号を送信中...")
-    # streamが初期化されていることを確認
+    """
+    Stop generation by pushing 'end' signal into the queue.
+    """
+    print("User clicked the stop button, sending 'end' signal...")
+    global stream
     if 'stream' in globals() and stream is not None:
-        # 送信前にキューの状態を確認
         try:
             current_top = stream.input_queue.top()
-            print(f"【デバッグ】現在のキュー先頭信号: {current_top}")
+            print(f"Queue top signal: {current_top}")
         except Exception as e:
-            print(f"【デバッグ】キュー状態確認中にエラー: {e}")
-            
-        # end信号を送信
+            print(f"Error checking queue status: {e}")
         try:
             stream.input_queue.push('end')
-            print("【デバッグ】キューにend信号を正常に送信しました")
-            
-            # 信号が正常に送信されたか確認
-            try:
-                current_top_after = stream.input_queue.top()
-                print(f"【デバッグ】送信後のキュー先頭信号: {current_top_after}")
-            except Exception as e:
-                print(f"【デバッグ】送信後のキュー状態確認中にエラー: {e}")
-                
+            print("Successfully pushed 'end' signal.")
         except Exception as e:
-            print(f"【デバッグ】キューへのend信号送信に失敗: {e}")
+            print(f"Error pushing 'end' signal: {e}")
     else:
-        print("【デバッグ】警告: streamが初期化されていないため、停止信号を送信できません")
+        print("Warning: 'stream' is not initialized; cannot stop.")
     return None
 
 
 quick_prompts = [
-    'The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view',
+    ["The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view"]
 ]
-quick_prompts = [[x] for x in quick_prompts]
 
-
-# カスタムCSSを作成し、レスポンシブレイアウトのサポートを追加
 def make_custom_css():
-    progress_bar_css = make_progress_bar_css()
-    
-    responsive_css = """
-    /* 基本レスポンシブ設定 */
+    base_progress_css = make_progress_bar_css()
+    enhanced_css = """
+    body {
+        background: #f9fafb !important;
+        font-family: "Noto Sans", sans-serif;
+    }
     #app-container {
-        max-width: 100%;
+        max-width: 1200px;
         margin: 0 auto;
+        padding: 1rem;
+        position: relative;
     }
-    
-    
-    /* ページタイトルのスタイル */
     h1 {
         font-size: 2rem;
         text-align: center;
         margin-bottom: 1rem;
+        color: #2d3748;
+        font-weight: 700;
     }
-    
-    /* ボタンのスタイル */
     .start-btn, .stop-btn {
         min-height: 45px;
         font-size: 1rem;
+        font-weight: 600;
     }
-    
-    /* モバイルデバイスのスタイル - 小画面 */
-    @media (max-width: 768px) {
-        h1 {
-            font-size: 1.5rem;
-            margin-bottom: 0.5rem;
-        }
-        
-        /* 単一カラムレイアウト */
-        .mobile-full-width {
-            flex-direction: column !important;
-        }
-        
-        .mobile-full-width > .gr-block {
-            min-width: 100% !important;
-            flex-grow: 1;
-        }
-        
-        /* 動画サイズの調整 */
-        .video-container {
-            height: auto !important;
-        }
-        
-        /* ボタンサイズの調整 */
-        .button-container button {
-            min-height: 50px;
-            font-size: 1rem;
-            touch-action: manipulation;
-        }
-        
-        /* スライダーの調整 */
-        .slider-container input[type="range"] {
-            height: 30px;
-        }
-    }
-    
-    /* タブレットデバイスのスタイル */
-    @media (min-width: 769px) and (max-width: 1024px) {
-        .tablet-adjust {
-            width: 48% !important;
-        }
+    .start-btn {
+        background-color: #3182ce !important;
+        color: #fff !important;
     }
-    
-    /* ダークモードサポート */
-    @media (prefers-color-scheme: dark) {
-        .dark-mode-text {
-            color: #f0f0f0;
-        }
-        
-        .dark-mode-bg {
-            background-color: #2a2a2a;
-        }
+    .stop-btn {
+        background-color: #e53e3e !important;
+        color: #fff !important;
     }
-    
-    /* アクセシビリティの向上 */
-    button, input, select, textarea {
-        font-size: 16px; /* iOSでの拡大を防止 */
-    }
-    
-    /* タッチ操作の最適化 */
-    button, .interactive-element {
-        min-height: 44px;
-        min-width: 44px;
+    .button-container button:hover {
+        filter: brightness(0.95);
     }
-    
-    /* コントラストの向上 */
-    .high-contrast {
-        color: #fff;
-        background-color: #000;
+    .preview-container, .video-container {
+        border: 1px solid #cbd5e0;
+        border-radius: 8px;
+        overflow: hidden;
     }
-    
-    /* プログレスバーのス���イル強化 */
     .progress-container {
-        margin-top: 10px;
-        margin-bottom: 10px;
+        margin-top: 15px;
+        margin-bottom: 15px;
     }
-    
-    /* エラーメッセージのスタイル */
-    #error-message {
-        color: #ff4444;
-        font-weight: bold;
-        padding: 10px;
-        border-radius: 4px;
-        margin-top: 10px;
-    }
-    
-    /* エラーコンテナの正しい表示 */
     .error-message {
-        background-color: rgba(255, 0, 0, 0.1);
+        background-color: #fff5f5;
+        border: 1px solid #fed7d7;
+        color: #e53e3e;
         padding: 10px;
         border-radius: 4px;
         margin-top: 10px;
-        border: 1px solid #ffcccc;
-    }
-    
-    /* 多言語エラーメッセージの処理 */
-    .error-msg-en, .error-msg-ja {
-        font-weight: bold;
     }
-    
-    /* エラーアイコン */
     .error-icon {
-        color: #ff4444;
-        font-size: 18px;
+        color: #e53e3e;
         margin-right: 8px;
     }
-    
-    /* 空のエラーメッセージが背景とボーダーを表示しないことを確認 */
-    #error-message:empty {
-        background-color: transparent;
-        border: none;
-        padding: 0;
-        margin: 0;
+    #error-message {
+        color: #ff4444;
+        font-weight: bold;
+        padding: 10px;
+        border-radius: 4px;
+        margin-top: 10px;
     }
-    
-    /* Gradioのデフォルトエラー表示の修正 */
-    .error {
-        display: none !important;
+    @media (max-width: 768px) {
+        #app-container {
+            padding: 0.5rem;
+        }
+        .mobile-full-width {
+            flex-direction: column !important;
+        }
+        .mobile-full-width > .gr-block {
+            width: 100% !important;
+        }
     }
     """
-    
-    # CSSを結合
-    combined_css = progress_bar_css + responsive_css
-    return combined_css
-
+    return base_progress_css + enhanced_css
 
 css = make_custom_css()
+
 block = gr.Blocks(css=css).queue()
 with block:
-    gr.HTML("<h1 ='title'>FramePack_rotate_landscape - 風景画像回転動画生成</h1>")
+    gr.HTML("<h1>FramePack Rotate-Landscape - Generate Rotating Landscape Video</h1>")
     
-    # mobile-full-widthクラスを持つレスポンシブ行を使用
     with gr.Row(elem_classes="mobile-full-width"):
-        with gr.Column(scale=1, elem_classes="mobile-full-width"):
-            # 二言語ラベルを追加 - 画像アップロード
+        with gr.Column(scale=1):
             input_image = gr.Image(
-                sources='upload', 
-                type="numpy", 
-                label="画像をアップロード / Upload Image", 
-                elem_id="input-image",
+                sources='upload',
+                type="numpy",
+                label="Upload Image",
                 height=320
             )
-            
+
             prompt = gr.Textbox(
-                label="プロンプト / Prompt", 
-                value='The camera smoothly orbits around the center of the scene, keeping the center point fixed and always in view',
-                elem_id="prompt-input"
+                label="Prompt",
+                value='The camera smoothly orbits around the center of the scene...',
             )
-            
+
             example_quick_prompts = gr.Dataset(
-                samples=quick_prompts, 
-                label='クイックプロンプト一覧 / Quick Prompts', 
-                samples_per_page=1000, 
+                samples=quick_prompts,
+                label="Quick Prompts",
+                samples_per_page=1000,
                 components=[prompt]
             )
-            example_quick_prompts.click(lambda x: x[0], inputs=[example_quick_prompts], outputs=prompt, show_progress=False, queue=False)
+            example_quick_prompts.click(
+                lambda x: x[0],
+                inputs=[example_quick_prompts],
+                outputs=prompt,
+                show_progress=False,
+                queue=False
+            )
 
-            # スタイルと二言語ラベルを追加したボタン
             with gr.Row(elem_classes="button-container"):
                 start_button = gr.Button(
-                    value="生成開始 / Generate", 
-                    elem_classes="start-btn", 
-                    elem_id="start-button",
+                    value="Generate",
+                    elem_classes="start-btn",
                     variant="primary"
                 )
-                
                 end_button = gr.Button(
-                    value="停止 / Stop", 
-                    elem_classes="stop-btn", 
-                    elem_id="stop-button",
+                    value="Stop",
+                    elem_classes="stop-btn",
                     interactive=False
                 )
 
-            # パラメータ設定エリア
-            with gr.Group():
-                use_teacache = gr.Checkbox(
-                    label='TeaCacheを使用 / Use TeaCache', 
-                    value=True, 
-                    info='処理速度が速くなりますが、指や手の生成品質が若干低下する可能性があります。 / Faster speed, but may result in slightly worse finger and hand generation.'
-                )
-
-                n_prompt = gr.Textbox(label="ネガティブプロンプト / Negative Prompt", value="", visible=False)  # 使用しない
-                
-                seed = gr.Number(
-                    label="シード値 / Seed", 
-                    value=31337, 
-                    precision=0
-                )
+            use_teacache = gr.Checkbox(
+                label="Use TeaCache",
+                value=True,
+                info="Faster speed, but possibly worse finger/hand generation."
+            )
+            n_prompt = gr.Textbox(label="Negative Prompt", value="", visible=False)
+            seed = gr.Number(label="Seed", value=31337, precision=0)
+            total_second_length = gr.Slider(
+                label="Video length (max 3 seconds)",
+                minimum=0.5, maximum=3, value=1.0, step=0.1
+            )
 
-                # タッチ操作を最適化するためにslider-containerクラスを追加
-                with gr.Group(elem_classes="slider-container"):
-                    total_second_length = gr.Slider(
-                        label="動画の長さ（最大3秒） / Video Length (max 3 seconds)", 
-                        minimum=0.5, 
-                        maximum=3, 
-                        value=1, 
-                        step=0.1
-                    )
-                    
-        # 右側のプレビューと結果カラム
-        with gr.Column(scale=1, elem_classes="mobile-full-width"):
-            # プレビュー画像
+        with gr.Column(scale=1):
             preview_image = gr.Image(
-                label="プレビュー / Preview", 
-                height=200, 
+                label="Preview",
+                height=200,
                 visible=False,
                 elem_classes="preview-container"
             )
-            
-            # 動画結果コンテナ
             result_video = gr.Video(
-                label="生成された動画 / Generated Video", 
-                autoplay=True, 
-                show_share_button=True,  # 共有ボタンを追加
-                height=512, 
+                label="Generated Video",
+                autoplay=True,
                 loop=True,
-                elem_classes="video-container",
-                elem_id="result-video"
+                show_share_button=True,
+                height=512,
+                elem_classes="video-container"
             )
-            
-            gr.HTML("<div ='sampling_note' class='note'>注意：逆順サンプリングのため、終了動作が開始動作より先に生成されます。開始動作が動画に表示されていない場合は、しばらくお待ちください。後で生成されます。</div>")
-            gr.HTML("<div ='sampling_note' class='note'>Note that the ending actions will be generated before the starting actions due to the inverted sampling. If the starting action is not in the video, you just need to wait, and it will be generated later.</div>")
+            gr.HTML("""
+            <div>
+                Note: Due to reversed sampling, ending actions may appear before starting actions. If the start action is missing, please wait for further frames.
+            </div>
+            """)
 
-            # 進捗インジケーター
             with gr.Group(elem_classes="progress-container"):
-                progress_desc = gr.Markdown('', elem_classes='no-generating-animation')
-                progress_bar = gr.HTML('', elem_classes='no-generating-animation')
-            
-            # エラーメッセージエリア - カスタムエラーメッセージ形式をサポートするHTMLコンポーネントを使用
+                progress_desc = gr.Markdown('')
+                progress_bar = gr.HTML('')
+
             error_message = gr.HTML('', elem_id='error-message', visible=True)
     
-    # 処理関数
+    # Inputs
     ips = [input_image, prompt, n_prompt, seed, total_second_length, use_teacache]
-    
-    # 開始と終了ボタンのイベント
-    start_button.click(fn=process, inputs=ips, outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button])
+    start_button.click(
+        fn=process,
+        inputs=ips,
+        outputs=[result_video, preview_image, progress_desc, progress_bar, start_button, end_button]
+    )
     end_button.click(fn=end_process)
 
-
-block.launch() 
-
+block.launch()