convert_hunyuan_video_to_diffusers.py not working - invalid load key, '\xd8'.

[FurkanGozukara]

I am trying to convert this lora and tested all configs but failing

https://civitai.com/models/1084814/studio-ghibli-style-hunyuanvideo

tested configs as below

Error is

Conversion complete. Processed 1 files with 0 successes and 1 failures.

Error converting studio_ghibli_hv_v03_19.safetensors: invalid load key, '\xd8'.

Thank you so much

@a-r-r-o-w

System Info

Q:\FramePack_v1\FramePack\venv\Scripts>diffusers-cli env
W0420 18:03:12.646000 29284 Lib\site-packages\torch\distributed\elastic\multiprocessing\redirects.py:29] NOTE: Redirects are currently not supported in Windows or MacOs.
[2025-04-20 18:03:13,334] [INFO] [real_accelerator.py:222:get_accelerator] Setting ds_accelerator to cuda (auto detect)
test.c
LINK : fatal error LNK1181: cannot open input file 'aio.lib'
test.c
LINK : fatal error LNK1181: cannot open input file 'cufile.lib'

Copy-and-paste the text below in your GitHub issue and FILL OUT the two last points.

- 🤗 Diffusers version: 0.33.1
- Platform: Windows-10-10.0.26100-SP0
- Running on Google Colab?: No
- Python version: 3.10.11
- PyTorch version (GPU?): 2.7.0.dev20250311+cu128 (True)
- Flax version (CPU?/GPU?/TPU?): not installed (NA)
- Jax version: not installed
- JaxLib version: not installed
- Huggingface_hub version: 0.30.2
- Transformers version: 4.51.3
- Accelerate version: 1.6.0
- PEFT version: 0.15.2
- Bitsandbytes version: not installed
- Safetensors version: 0.5.3
- xFormers version: not installed
- Accelerator: NVIDIA GeForce RTX 5090, 32607 MiB
NVIDIA GeForce RTX 3090 Ti, 24564 MiB
- Using GPU in script?: <fill in>
- Using distributed or parallel set-up in script?: <fill in>


Q:\FramePack_v1\FramePack\venv\Scripts>

Who can help?

@a-r-r-o-w

full error

Converting C:\Users\Furkan\Music\g\studio_ghibli_hv_v03_19.safetensors with type HYVideo-T/2-cfgdistill and dtype bf16
WARNING: Loading C:\Users\Furkan\Music\g\studio_ghibli_hv_v03_19.safetensors with weights_only=False. Only do this with files from trusted sources as it can result in arbitrary code execution.
Traceback (most recent call last):
  File "Q:\FramePack_v1\FramePack\convert_loras.py", line 124, in convert_lora_file
    transformer = convert_transformer(input_file, transformer_type)
  File "Q:\FramePack_v1\FramePack\convert_hunyuan_video_to_diffusers.py", line 223, in convert_transformer
    original_state_dict = get_state_dict(torch.load(ckpt_path, map_location="cpu", weights_only=False))
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\torch\serialization.py", line 1549, in load
    return _legacy_load(
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\torch\serialization.py", line 1797, in _legacy_load
    magic_number = pickle_module.load(f, **pickle_load_args)
_pickle.UnpicklingError: invalid load key, '\xd8'.
Converting C:\Users\Furkan\Music\g\studio_ghibli_hv_v03_19.safetensors with type HYVideo-T/2-I2V-33ch and dtype bf16
WARNING: Loading C:\Users\Furkan\Music\g\studio_ghibli_hv_v03_19.safetensors with weights_only=False. Only do this with files from trusted sources as it can result in arbitrary code execution.
Traceback (most recent call last):
  File "Q:\FramePack_v1\FramePack\convert_loras.py", line 124, in convert_lora_file
    transformer = convert_transformer(input_file, transformer_type)
  File "Q:\FramePack_v1\FramePack\convert_hunyuan_video_to_diffusers.py", line 223, in convert_transformer
    original_state_dict = get_state_dict(torch.load(ckpt_path, map_location="cpu", weights_only=False))
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\torch\serialization.py", line 1549, in load
    return _legacy_load(
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\torch\serialization.py", line 1797, in _legacy_load
    magic_number = pickle_module.load(f, **pickle_load_args)
_pickle.UnpicklingError: invalid load key, '\xd8'.
Converting C:\Users\Furkan\Music\g\studio_ghibli_hv_v03_19.safetensors with type HYVideo-T/2-I2V-16ch and dtype bf16
WARNING: Loading C:\Users\Furkan\Music\g\studio_ghibli_hv_v03_19.safetensors with weights_only=False. Only do this with files from trusted sources as it can result in arbitrary code execution.
Traceback (most recent call last):
  File "Q:\FramePack_v1\FramePack\convert_loras.py", line 124, in convert_lora_file
    transformer = convert_transformer(input_file, transformer_type)
  File "Q:\FramePack_v1\FramePack\convert_hunyuan_video_to_diffusers.py", line 223, in convert_transformer
    original_state_dict = get_state_dict(torch.load(ckpt_path, map_location="cpu", weights_only=False))
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\torch\serialization.py", line 1549, in load
    return _legacy_load(
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\torch\serialization.py", line 1797, in _legacy_load
    magic_number = pickle_module.load(f, **pickle_load_args)
_pickle.UnpicklingError: invalid load key, '\xd8'.

[a-r-r-o-w]

The conversion script that you're trying to use is for original format to diffusers if you have the full model. To convert loras, you can take reference from:

diffusers/src/diffusers/loaders/lora_conversion_utils.py

Line 1332 in 5873377

def _convert_hunyuan_video_lora_to_diffusers(original_state_dict):

[FurkanGozukara]

The conversion script that you're trying to use is for original format to diffusers if you have the full model. To convert loras, you can take reference from:

diffusers/src/diffusers/loaders/lora_conversion_utils.py

Line 1332 in 5873377

def _convert_hunyuan_video_lora_to_diffusers(original_state_dict):

thank you. i tried like this but no lock @a-r-r-o-w

def convert_lora_file(
    input_file: str,
    output_path: str,
) -> Tuple[bool, str]:
    """
    Convert a single HunyuanVideo-compatible LoRA file using the specific diffusers conversion utility.
    Loads the state dict directly from the file path.

    Args:
        input_file: Path to the input LoRA file.
        output_path: Path where to save the converted model.

    Returns:
        Tuple of (success, message)
    """
    try:
        input_path_obj = Path(input_file)
        output_path_obj = Path(output_path)

        if not input_path_obj.is_file():
            return False, f"Error: Input file not found: {input_file}"

        print(f"Converting {input_path_obj.name} using HunyuanVideo converter")

        # Direct State Dict Loading
        print(f"Loading state dict directly from: {input_file}")
        file_extension = input_path_obj.suffix.lower()
        state_dict = None

        if file_extension == ".safetensors":
            if HAS_SAFETENSORS:
                try:
                    state_dict = load_safetensors_file(input_file, device="cpu")
                    print(f"Loaded state dict from safetensors file.")
                except Exception as e:
                    return False, f"Error loading safetensors file '{input_path_obj.name}': {e}"
            else:
                return False, "Error: .safetensors file provided, but 'safetensors' library is not installed. Please install it (`pip install safetensors`)."
        elif file_extension in [".pt", ".ckpt", ".bin"]:
             try:
                state_dict = torch.load(input_file, map_location="cpu")
                if isinstance(state_dict, dict):
                     # Common practice: Check for weights under 'state_dict' key
                     if 'state_dict' in state_dict and isinstance(state_dict['state_dict'], dict):
                          state_dict = state_dict['state_dict']
                          print("Loaded nested state_dict found under 'state_dict' key.")
                     # Add checks for other potential top-level keys if needed (e.g., 'model')
                     # else: remains the original state_dict if 'state_dict' key isn't present or not a dict
                else:
                    # Handle cases where torch.load returns the model object directly
                    if hasattr(state_dict, 'state_dict') and callable(state_dict.state_dict):
                        state_dict = state_dict.state_dict()
                        print("Loaded state_dict from model object.")
                    else:
                         return False, f"Error: Loaded file '{input_path_obj.name}' is not a dictionary or recognized model object."
                print(f"Loaded state dict from {file_extension} file.")
             except Exception as e:
                 return False, f"Error loading PyTorch file '{input_path_obj.name}': {e}"
        else:
            return False, f"Error: Unsupported file extension '{file_extension}' for file '{input_path_obj.name}'"

        if not isinstance(state_dict, dict): # Final check after potential unwrapping
             return False, f"Error: Failed to load a valid state dictionary (dict type) from '{input_path_obj.name}'."
        # -----------------------------------

        # Create output filename
        file_basename = input_path_obj.stem
        output_file = output_path_obj / f"{file_basename}_converted.safetensors"

        # Convert the state dict using the HunyuanVideo specific conversion function
        print(f"Applying _convert_hunyuan_video_lora_to_diffusers to {input_path_obj.name}")
        converted_state_dict = _convert_hunyuan_video_lora_to_diffusers(state_dict)

        # --- Filter for Tensors Only Before Saving ---
        # Safetensors can only save tensors, remove any other metadata
        filtered_state_dict = {
            k: v for k, v in converted_state_dict.items() if isinstance(v, torch.Tensor)
        }
        num_original = len(converted_state_dict)
        num_filtered = len(filtered_state_dict)
        if num_filtered < num_original:
            removed_count = num_original - num_filtered
            print(f"Warning: Filtered out {removed_count} non-tensor item(s) from the state dict before saving.")
            # For debugging, you might want to see which keys were removed:
            # removed_keys = set(converted_state_dict.keys()) - set(filtered_state_dict.keys())
            # print(f"Removed keys: {removed_keys}")
        # -------------------------------------------

        # Ensure output directory exists
        output_file.parent.mkdir(parents=True, exist_ok=True)

        # Save the FILTERED state dict using safetensors if possible
        save_method = "N/A"
        if HAS_SAFETENSORS:
            try:
                # Save the filtered dictionary
                save_safetensors_file(filtered_state_dict, str(output_file))
                save_method = "safetensors"
            except Exception as e:
                print(f"Warning: Failed to save with safetensors ({e}), falling back to torch.save().")
                # Fallback to torch.save if safetensors fails
                try:
                    torch.save(filtered_state_dict, str(output_file)) # Save filtered dict with torch
                    save_method = "torch"
                except Exception as te:
                    return False, f"Error saving converted state dict using torch.save for '{output_file.name}': {te}"
        else:
            # Save with torch if safetensors is not installed
            try:
                torch.save(filtered_state_dict, str(output_file)) # Save filtered dict with torch
                save_method = "torch"
            except Exception as te:
                 return False, f"Error saving converted state dict using torch.save for '{output_file.name}': {te}"

        if save_method != "N/A":
            return True, f"Successfully converted '{input_path_obj.name}' to '{output_file.name}' using {save_method}."
        else:
             return False, f"Error: Failed to save the converted file '{output_file.name}'."

    except Exception as e:
        error_msg = f"Error converting {os.path.basename(input_file)}: {type(e).__name__} - {str(e)}"
        print(f"\n--- Error Traceback for {os.path.basename(input_file)} ---")
        traceback.print_exc()
        print("--- End Traceback ---\n")
        return False, error_msg

Error loading LoRA Q:\FramePack_v1\FramePack\loras\studio_ghibli_hv_v03_19_converted.safetensors: Error while deserializing header: HeaderTooLarge
Traceback (most recent call last):
  File "Q:\FramePack_v1\FramePack\app.py", line 636, in worker
    current_transformer = load_lora(transformer, lora_path, lora_name)
  File "Q:\FramePack_v1\FramePack\diffusers_helper\load_lora.py", line 14, in load_lora
    state_dict = _fetch_state_dict(
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\diffusers\loaders\lora_base.py", line 241, in _fetch_state_dict
    raise e
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\diffusers\loaders\lora_base.py", line 238, in _fetch_state_dict
    state_dict = safetensors.torch.load_file(model_file, device="cpu")
  File "Q:\FramePack_v1\FramePack\venv\lib\site-packages\safetensors\torch.py", line 313, in load_file
    with safe_open(filename, framework="pt", device=device) as f:
safetensors_rust.SafetensorError: Error while deserializing header: HeaderTooLarge
latent_padding_size = 27, is_last_section = False, is_first_section = True

[github-actions]

This issue has been automatically marked as stale because it has not had recent activity. If you think this still needs to be addressed please comment on this thread.

Please note that issues that do not follow the contributing guidelines are likely to be ignored.