Musubi Tuner

English | 日本語

Table of Contents

Click to expand

• Musubi Tuner
  • Table of Contents
  • Introduction
    • Sponsors
    • Support the Project
    • Recent Updates
    • Releases
    • For Developers Using AI Coding Agents
  • Overview
    • Hardware Requirements
    • Features
    • Documentation
  • Installation
    • pip based installation
    • uv based installation
    • Linux/MacOS
    • Windows
  • Model Download
  • Usage
    • Dataset Configuration
    • Pre-caching and Training
    • Configuration of Accelerate
    • Training and Inference
  • Miscellaneous
    • SageAttention Installation
    • PyTorch version
  • Disclaimer
  • Contributing
  • License

Introduction

This repository provides scripts for training LoRA (Low-Rank Adaptation) models with HunyuanVideo, Wan2.1/2.2, FramePack, FLUX.1 Kontext, and Qwen-Image architectures.

This repository is unofficial and not affiliated with the official HunyuanVideo/Wan2.1/2.2/FramePack/FLUX.1 Kontext/Qwen-Image repositories.

This repository is under development.

Sponsors

We are grateful to the following companies for their generous sponsorship:

Support the Project

If you find this project helpful, please consider supporting its development via GitHub Sponsors. Your support is greatly appreciated!

Recent Updates

GitHub Discussions Enabled: We've enabled GitHub Discussions for community Q&A, knowledge sharing, and technical information exchange. Please use Issues for bug reports and feature requests, and Discussions for questions and sharing experiences. Join the conversation →

• October 13, 2025

  • Added Reference Consistency Mask (RCM) feature to Qwen-Image-Edit, 2509 inference script to improve pixel-level consistency of generated images. See PR #643
    • RCM addresses the issue of slight positional drift in generated images compared to the control image. For details, refer to the Qwen-Image documentation.
  • Fixed a bug where the control image was being resized to match the output image size even when the --resize_control_to_image_size option was not specified. This may change the generated images, so please check your options.
  • FramePack 1-frame inference now includes the --one_frame_auto_resize option. PR #646
    • Automatically adjusts the resolution of the generated image. This option is only effective when --one_frame_inference is specified. For details, refer to the FramePack 1-frame inference documentation.

• October 5, 2025

  • Changed the epoch switching from collate_fn to before the start of the DataLoader fetching loop. See PR #601 for more details.

  • In the previous implementation, the ARB buckets were shuffled after fetching the first data of the epoch. Therefore, the first data of the epoch was fetched in the ARB sorted order of the previous epoch. This caused duplication and omission of data within the epoch.

  • Each DataSet now shuffles the ARB buckets immediately after detecting a change in the shared epoch in __getitem__. This ensures that data is fetched in the new order from the beginning, eliminating duplication and omission.

  • Since the shuffle timing has been moved forward, the sample order will not be the same as the old implementation even with the same seed.

  • Impact on overall training:

    • This fix addresses the issue of incorrect fetching of the first sample at epoch boundaries. Since each sample is ultimately used without omission or duplication over multiple epochs, the overall impact on training is minimal. The change primarily enhances "consistency in consumption order within an epoch," and the long-term training behavior remains practically unchanged under the same conditions (※ there may be observable differences in cases of extremely few epochs or early stopping).

  • Added a method to specify training options in a configuration file in the Advanced Configuration documentation. See PR #630.

  • Restructured the documentation. Moved dataset configuration-related documentation to docs/dataset_config.md.

• October 3, 2025

  • Improved the block swap mechanism used in each training script to significantly reduce shared GPU memory usage in Windows environments. See PR #585
    • Changed the block swap offload destination from shared GPU memory to CPU memory. This does not change the total memory usage but significantly reduces shared GPU memory usage.
    • For example, with 32GB of main memory, previously only up to 16GB could be offloaded, but with this change, it can be offloaded up to "32GB - other usage".
    • Training speed may decrease slightly. For technical details, see PR #585.

• September 30, 2025

  • Fixed a bug in Qwen-Image-Edit-2509 LoRA training that prevented handling multiple control images correctly. See PR #612

• September 28, 2025

  • Support for training and inference of Qwen-Image-Edit-2509 has been added. See PR #590 for details. Please refer to the Qwen-Image documentation for more information.
    • Multiple control images can be used simultaneously. While the official Qwen-Image-Edit-2509 supports up to 3 images, Musubi Tuner allows specifying any number of images (though correct operation is confirmed only up to 3).
    • Different weights for the DiT model are required, and the --edit_plus option has been added to the caching, training, and inference scripts.

• September 24, 2025

  • Added --force_v2_1_time_embedding option to Wan2.2 LoRA training and inference scripts. See PR #586 This option can reduce VRAM usage. See Wan documentation for details.

• September 23, 2025

  • The method of quantization when the --fp8_scaled option is specified has been changed from per-tensor to block-wise scaling. See PR #575 Discussion #564 for more details.
    • This improves the accuracy of FP8 quantization, leading to more stable training and improved inference accuracy for each model (except HunyuanVideo). Training and inference speed may decrease slightly.
    • For LoRA training of Qwen-Image, the required VRAM for training is reduced by about 5GB due to a review of the quantized modules.
    • See Advanced Configuration documentation for details.

Releases

We are grateful to everyone who has been contributing to the Musubi Tuner ecosystem through documentation and third-party tools. To support these valuable contributions, we recommend working with our releases as stable reference points, as this project is under active development and breaking changes may occur.

You can find the latest release and version history in our releases page.

For Developers Using AI Coding Agents

This repository provides recommended instructions to help AI agents like Claude and Gemini understand our project context and coding standards.

To use them, you need to opt-in by creating your own configuration file in the project root.

Quick Setup:

1. Create a CLAUDE.md and/or GEMINI.md file in the project root.

2. Add the following line to your CLAUDE.md to import the repository's recommended prompt (currently they are the almost same):

   @./.ai/claude.prompt.md

   or for Gemini:

   @./.ai/gemini.prompt.md

3. You can now add your own personal instructions below the import line (e.g., Always respond in Japanese.).

This approach ensures that you have full control over the instructions given to your agent while benefiting from the shared project context. Your CLAUDE.md and GEMINI.md are already listed in .gitignore, so it won't be committed to the repository.

Overview

Hardware Requirements

• VRAM: 12GB or more recommended for image training, 24GB or more for video training
  • Actual requirements depend on resolution and training settings. For 12GB, use a resolution of 960x544 or lower and use memory-saving options such as --blocks_to_swap, --fp8_llm, etc.
• Main Memory: 64GB or more recommended, 32GB + swap may work

Features

• Memory-efficient implementation
• Windows compatibility confirmed (Linux compatibility confirmed by community)
• Multi-GPU training (using Accelerate), documentation will be added later

Documentation

For detailed information on specific architectures, configurations, and advanced features, please refer to the documentation below.

Architecture-specific:

• HunyuanVideo
• Wan2.1/2.2
• Wan2.1/2.2 (Single Frame)
• FramePack
• FramePack (Single Frame)
• FLUX.1 Kontext
• Qwen-Image

Common Configuration & Usage:

• Dataset Configuration
• Advanced Configuration
• Sampling during Training
• Tools and Utilities

Installation

pip based installation

Python 3.10 or later is required (verified with 3.10).

Create a virtual environment and install PyTorch and torchvision matching your CUDA version.

PyTorch 2.5.1 or later is required (see note).

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124

Install the required dependencies using the following command.

pip install -e .

Optionally, you can use FlashAttention and SageAttention (for inference only; see SageAttention Installation for installation instructions).

Optional dependencies for additional features:

• ascii-magic: Used for dataset verification
• matplotlib: Used for timestep visualization
• tensorboard: Used for logging training progress
• prompt-toolkit: Used for interactive prompt editing in Wan2.1 and FramePack inference scripts. If installed, it will be automatically used in interactive mode. Especially useful in Linux environments for easier prompt editing.

pip install ascii-magic matplotlib tensorboard prompt-toolkit

uv based installation (experimental)

You can also install using uv, but installation with uv is experimental. Feedback is welcome.

1. Install uv (if not already present on your OS).

Linux/MacOS

curl -LsSf https://astral.sh/uv/install.sh | sh

Follow the instructions to add the uv path manually until you restart your session...

Windows

powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

Follow the instructions to add the uv path manually until you reboot your system... or just reboot your system at this point.

Model Download

Model download procedures vary by architecture. Please refer to the architecture-specific documents in the Documentation section for instructions.

Usage

Dataset Configuration

Please refer to here.

Pre-caching

Pre-caching procedures vary by architecture. Please refer to the architecture-specific documents in the Documentation section for instructions.

Configuration of Accelerate

Run accelerate config to configure Accelerate. Choose appropriate values for each question based on your environment (either input values directly or use arrow keys and enter to select; uppercase is default, so if the default value is fine, just press enter without inputting anything). For training with a single GPU, answer the questions as follows:

- In which compute environment are you running?: This machine
- Which type of machine are you using?: No distributed training
- Do you want to run your training on CPU only (even if a GPU / Apple Silicon / Ascend NPU device is available)?[yes/NO]: NO
- Do you wish to optimize your script with torch dynamo?[yes/NO]: NO
- Do you want to use DeepSpeed? [yes/NO]: NO
- What GPU(s) (by id) should be used for training on this machine as a comma-seperated list? [all]: all
- Would you like to enable numa efficiency? (Currently only supported on NVIDIA hardware). [yes/NO]: NO
- Do you wish to use mixed precision?: bf16

Note: In some cases, you may encounter the error ValueError: fp16 mixed precision requires a GPU. If this happens, answer "0" to the sixth question (What GPU(s) (by id) should be used for training on this machine as a comma-separated list? [all]:). This means that only the first GPU (id 0) will be used.

Training and Inference

Training and inference procedures vary significantly by architecture. Please refer to the architecture-specific documents in the Documentation section and the various configuration documents for detailed instructions.

Miscellaneous

SageAttention Installation

sdbsd has provided a Windows-compatible SageAttention implementation and pre-built wheels here: https://github.com/sdbds/SageAttention-for-windows. After installing triton, if your Python, PyTorch, and CUDA versions match, you can download and install the pre-built wheel from the Releases page. Thanks to sdbsd for this contribution.

For reference, the build and installation instructions are as follows. You may need to update Microsoft Visual C++ Redistributable to the latest version.

1. Download and install triton 3.1.0 wheel matching your Python version from here.

2. Install Microsoft Visual Studio 2022 or Build Tools for Visual Studio 2022, configured for C++ builds.

3. Clone the SageAttention repository in your preferred directory:

   git clone https://github.com/thu-ml/SageAttention.git

4. Open x64 Native Tools Command Prompt for VS 2022 from the Start menu under Visual Studio 2022.

5. Activate your venv, navigate to the SageAttention folder, and run the following command. If you get a DISTUTILS not configured error, set set DISTUTILS_USE_SDK=1 and try again:

   python setup.py install

This completes the SageAttention installation.

PyTorch version

If you specify torch for --attn_mode, use PyTorch 2.5.1 or later (earlier versions may result in black videos).

If you use an earlier version, use xformers or SageAttention.

Disclaimer

This repository is unofficial and not affiliated with the official repositories of the supported architectures.

This repository is experimental and under active development. While we welcome community usage and feedback, please note:

• This is not intended for production use
• Features and APIs may change without notice
• Some functionalities are still experimental and may not work as expected
• Video training features are still under development

If you encounter any issues or bugs, please create an Issue in this repository with:

• A detailed description of the problem
• Steps to reproduce
• Your environment details (OS, GPU, VRAM, Python version, etc.)
• Any relevant error messages or logs

Contributing

We welcome contributions! Please see CONTRIBUTING.md for details.

License

Code under the hunyuan_model directory is modified from HunyuanVideo and follows their license.

Code under the wan directory is modified from Wan2.1. The license is under the Apache License 2.0.

Code under the frame_pack directory is modified from FramePack. The license is under the Apache License 2.0.

Other code is under the Apache License 2.0. Some code is copied and modified from Diffusers.