diff --git a/.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/RECORD b/.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..b7ba0b7bb80fd0875017e64854d731956e03a829 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/RECORD @@ -0,0 +1,14 @@ +MarkupSafe-3.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +MarkupSafe-3.0.2.dist-info/LICENSE.txt,sha256=SJqOEQhQntmKN7uYPhHg9-HTHwvY-Zp5yESOf_N9B-o,1475 +MarkupSafe-3.0.2.dist-info/METADATA,sha256=aAwbZhSmXdfFuMM-rEHpeiHRkBOGESyVLJIuwzHP-nw,3975 +MarkupSafe-3.0.2.dist-info/RECORD,, +MarkupSafe-3.0.2.dist-info/WHEEL,sha256=OVgtqZzfzIXXtylXP90gxCZ6CKBCwKYyHM8PpMEjN1M,151 +MarkupSafe-3.0.2.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11 +markupsafe/__init__.py,sha256=sr-U6_27DfaSrj5jnHYxWN-pvhM27sjlDplMDPZKm7k,13214 +markupsafe/__pycache__/__init__.cpython-312.pyc,, +markupsafe/__pycache__/_native.cpython-312.pyc,, +markupsafe/_native.py,sha256=hSLs8Jmz5aqayuengJJ3kdT5PwNpBWpKrmQSdipndC8,210 +markupsafe/_speedups.c,sha256=O7XulmTo-epI6n2FtMVOrJXl8EAaIwD2iNYmBI5SEoQ,4149 +markupsafe/_speedups.cpython-312-x86_64-linux-gnu.so,sha256=t1DBZlpsjFA30BOOvXfXfT1wvO_4cS16VbHz1-49q5U,43432 +markupsafe/_speedups.pyi,sha256=ENd1bYe7gbBUf2ywyYWOGUpnXOHNJ-cgTNqetlW8h5k,41 +markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 diff --git a/.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..75bf729258f9daef77370b6df1a57940f90fc23f --- /dev/null +++ b/.venv/lib/python3.12/site-packages/MarkupSafe-3.0.2.dist-info/top_level.txt @@ -0,0 +1 @@ +markupsafe diff --git a/.venv/lib/python3.12/site-packages/PIL/MspImagePlugin.py b/.venv/lib/python3.12/site-packages/PIL/MspImagePlugin.py new file mode 100644 index 0000000000000000000000000000000000000000..277087a8677708a3a5fe21a3f6d2c3b27f880d03 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/PIL/MspImagePlugin.py @@ -0,0 +1,200 @@ +# +# The Python Imaging Library. +# +# MSP file handling +# +# This is the format used by the Paint program in Windows 1 and 2. +# +# History: +# 95-09-05 fl Created +# 97-01-03 fl Read/write MSP images +# 17-02-21 es Fixed RLE interpretation +# +# Copyright (c) Secret Labs AB 1997. +# Copyright (c) Fredrik Lundh 1995-97. +# Copyright (c) Eric Soroos 2017. +# +# See the README file for information on usage and redistribution. +# +# More info on this format: https://archive.org/details/gg243631 +# Page 313: +# Figure 205. Windows Paint Version 1: "DanM" Format +# Figure 206. Windows Paint Version 2: "LinS" Format. Used in Windows V2.03 +# +# See also: https://www.fileformat.info/format/mspaint/egff.htm +from __future__ import annotations + +import io +import struct +from typing import IO + +from . import Image, ImageFile +from ._binary import i16le as i16 +from ._binary import o16le as o16 + +# +# read MSP files + + +def _accept(prefix: bytes) -> bool: + return prefix.startswith((b"DanM", b"LinS")) + + +## +# Image plugin for Windows MSP images. This plugin supports both +# uncompressed (Windows 1.0). + + +class MspImageFile(ImageFile.ImageFile): + format = "MSP" + format_description = "Windows Paint" + + def _open(self) -> None: + # Header + assert self.fp is not None + + s = self.fp.read(32) + if not _accept(s): + msg = "not an MSP file" + raise SyntaxError(msg) + + # Header checksum + checksum = 0 + for i in range(0, 32, 2): + checksum = checksum ^ i16(s, i) + if checksum != 0: + msg = "bad MSP checksum" + raise SyntaxError(msg) + + self._mode = "1" + self._size = i16(s, 4), i16(s, 6) + + if s.startswith(b"DanM"): + self.tile = [ImageFile._Tile("raw", (0, 0) + self.size, 32, "1")] + else: + self.tile = [ImageFile._Tile("MSP", (0, 0) + self.size, 32)] + + +class MspDecoder(ImageFile.PyDecoder): + # The algo for the MSP decoder is from + # https://www.fileformat.info/format/mspaint/egff.htm + # cc-by-attribution -- That page references is taken from the + # Encyclopedia of Graphics File Formats and is licensed by + # O'Reilly under the Creative Common/Attribution license + # + # For RLE encoded files, the 32byte header is followed by a scan + # line map, encoded as one 16bit word of encoded byte length per + # line. + # + # NOTE: the encoded length of the line can be 0. This was not + # handled in the previous version of this encoder, and there's no + # mention of how to handle it in the documentation. From the few + # examples I've seen, I've assumed that it is a fill of the + # background color, in this case, white. + # + # + # Pseudocode of the decoder: + # Read a BYTE value as the RunType + # If the RunType value is zero + # Read next byte as the RunCount + # Read the next byte as the RunValue + # Write the RunValue byte RunCount times + # If the RunType value is non-zero + # Use this value as the RunCount + # Read and write the next RunCount bytes literally + # + # e.g.: + # 0x00 03 ff 05 00 01 02 03 04 + # would yield the bytes: + # 0xff ff ff 00 01 02 03 04 + # + # which are then interpreted as a bit packed mode '1' image + + _pulls_fd = True + + def decode(self, buffer: bytes | Image.SupportsArrayInterface) -> tuple[int, int]: + assert self.fd is not None + + img = io.BytesIO() + blank_line = bytearray((0xFF,) * ((self.state.xsize + 7) // 8)) + try: + self.fd.seek(32) + rowmap = struct.unpack_from( + f"<{self.state.ysize}H", self.fd.read(self.state.ysize * 2) + ) + except struct.error as e: + msg = "Truncated MSP file in row map" + raise OSError(msg) from e + + for x, rowlen in enumerate(rowmap): + try: + if rowlen == 0: + img.write(blank_line) + continue + row = self.fd.read(rowlen) + if len(row) != rowlen: + msg = f"Truncated MSP file, expected {rowlen} bytes on row {x}" + raise OSError(msg) + idx = 0 + while idx < rowlen: + runtype = row[idx] + idx += 1 + if runtype == 0: + (runcount, runval) = struct.unpack_from("Bc", row, idx) + img.write(runval * runcount) + idx += 2 + else: + runcount = runtype + img.write(row[idx : idx + runcount]) + idx += runcount + + except struct.error as e: + msg = f"Corrupted MSP file in row {x}" + raise OSError(msg) from e + + self.set_as_raw(img.getvalue(), "1") + + return -1, 0 + + +Image.register_decoder("MSP", MspDecoder) + + +# +# write MSP files (uncompressed only) + + +def _save(im: Image.Image, fp: IO[bytes], filename: str | bytes) -> None: + if im.mode != "1": + msg = f"cannot write mode {im.mode} as MSP" + raise OSError(msg) + + # create MSP header + header = [0] * 16 + + header[0], header[1] = i16(b"Da"), i16(b"nM") # version 1 + header[2], header[3] = im.size + header[4], header[5] = 1, 1 + header[6], header[7] = 1, 1 + header[8], header[9] = im.size + + checksum = 0 + for h in header: + checksum = checksum ^ h + header[12] = checksum # FIXME: is this the right field? + + # header + for h in header: + fp.write(o16(h)) + + # image body + ImageFile._save(im, fp, [ImageFile._Tile("raw", (0, 0) + im.size, 32, "1")]) + + +# +# registry + +Image.register_open(MspImageFile.format, MspImageFile, _accept) +Image.register_save(MspImageFile.format, _save) + +Image.register_extension(MspImageFile.format, ".msp") diff --git a/.venv/lib/python3.12/site-packages/PIL/_imagingft.pyi b/.venv/lib/python3.12/site-packages/PIL/_imagingft.pyi new file mode 100644 index 0000000000000000000000000000000000000000..2136810ba6a95e0c025a71cf7fbbc5b60490fed7 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/PIL/_imagingft.pyi @@ -0,0 +1,70 @@ +from collections.abc import Callable +from typing import Any + +from . import ImageFont, _imaging + +class Font: + @property + def family(self) -> str | None: ... + @property + def style(self) -> str | None: ... + @property + def ascent(self) -> int: ... + @property + def descent(self) -> int: ... + @property + def height(self) -> int: ... + @property + def x_ppem(self) -> int: ... + @property + def y_ppem(self) -> int: ... + @property + def glyphs(self) -> int: ... + def render( + self, + string: str | bytes, + fill: Callable[[int, int], _imaging.ImagingCore], + mode: str, + dir: str | None, + features: list[str] | None, + lang: str | None, + stroke_width: float, + stroke_filled: bool, + anchor: str | None, + foreground_ink_long: int, + start: tuple[float, float], + /, + ) -> tuple[_imaging.ImagingCore, tuple[int, int]]: ... + def getsize( + self, + string: str | bytes | bytearray, + mode: str, + dir: str | None, + features: list[str] | None, + lang: str | None, + anchor: str | None, + /, + ) -> tuple[tuple[int, int], tuple[int, int]]: ... + def getlength( + self, + string: str | bytes, + mode: str, + dir: str | None, + features: list[str] | None, + lang: str | None, + /, + ) -> float: ... + def getvarnames(self) -> list[bytes]: ... + def getvaraxes(self) -> list[ImageFont.Axis]: ... + def setvarname(self, instance_index: int, /) -> None: ... + def setvaraxes(self, axes: list[float], /) -> None: ... + +def getfont( + filename: str | bytes, + size: float, + index: int, + encoding: str, + font_bytes: bytes, + layout_engine: int, +) -> Font: ... +def __getattr__(name: str) -> Any: ... diff --git a/.venv/lib/python3.12/site-packages/PIL/_imagingtk.cpython-312-x86_64-linux-gnu.so b/.venv/lib/python3.12/site-packages/PIL/_imagingtk.cpython-312-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..5ca935fc56aaa8224605756ba1a9788fafebf4e6 Binary files /dev/null and b/.venv/lib/python3.12/site-packages/PIL/_imagingtk.cpython-312-x86_64-linux-gnu.so differ diff --git a/.venv/lib/python3.12/site-packages/PIL/_imagingtk.pyi b/.venv/lib/python3.12/site-packages/PIL/_imagingtk.pyi new file mode 100644 index 0000000000000000000000000000000000000000..e27843e5338213713e26973127c738c14313ff98 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/PIL/_imagingtk.pyi @@ -0,0 +1,3 @@ +from typing import Any + +def __getattr__(name: str) -> Any: ... diff --git a/.venv/lib/python3.12/site-packages/PIL/_tkinter_finder.py b/.venv/lib/python3.12/site-packages/PIL/_tkinter_finder.py new file mode 100644 index 0000000000000000000000000000000000000000..9c0143003a7320dd475cfcd168168b82e4f64964 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/PIL/_tkinter_finder.py @@ -0,0 +1,20 @@ +"""Find compiled module linking to Tcl / Tk libraries""" + +from __future__ import annotations + +import sys +import tkinter + +tk = getattr(tkinter, "_tkinter") + +try: + if hasattr(sys, "pypy_find_executable"): + TKINTER_LIB = tk.tklib_cffi.__file__ + else: + TKINTER_LIB = tk.__file__ +except AttributeError: + # _tkinter may be compiled directly into Python, in which case __file__ is + # not available. load_tkinter_funcs will check the binary first in any case. + TKINTER_LIB = None + +tk_version = str(tkinter.TkVersion) diff --git a/.venv/lib/python3.12/site-packages/PIL/py.typed b/.venv/lib/python3.12/site-packages/PIL/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv/lib/python3.12/site-packages/PIL/report.py b/.venv/lib/python3.12/site-packages/PIL/report.py new file mode 100644 index 0000000000000000000000000000000000000000..d2815e8455e2ead803de4417314987ce7e9b7598 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/PIL/report.py @@ -0,0 +1,5 @@ +from __future__ import annotations + +from .features import pilinfo + +pilinfo(supported_formats=False) diff --git a/.venv/lib/python3.12/site-packages/filelock/_unix.py b/.venv/lib/python3.12/site-packages/filelock/_unix.py new file mode 100644 index 0000000000000000000000000000000000000000..b2fd0f33d25d2bdf4a2a883380154771b4a25f9b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/filelock/_unix.py @@ -0,0 +1,70 @@ +from __future__ import annotations + +import os +import sys +from contextlib import suppress +from errno import ENOSYS +from pathlib import Path +from typing import cast + +from ._api import BaseFileLock +from ._util import ensure_directory_exists + +#: a flag to indicate if the fcntl API is available +has_fcntl = False +if sys.platform == "win32": # pragma: win32 cover + + class UnixFileLock(BaseFileLock): + """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.""" + + def _acquire(self) -> None: + raise NotImplementedError + + def _release(self) -> None: + raise NotImplementedError + +else: # pragma: win32 no cover + try: + import fcntl + + _ = (fcntl.flock, fcntl.LOCK_EX, fcntl.LOCK_NB, fcntl.LOCK_UN) + except (ImportError, AttributeError): + pass + else: + has_fcntl = True + + class UnixFileLock(BaseFileLock): + """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.""" + + def _acquire(self) -> None: + ensure_directory_exists(self.lock_file) + open_flags = os.O_RDWR | os.O_TRUNC + if not Path(self.lock_file).exists(): + open_flags |= os.O_CREAT + fd = os.open(self.lock_file, open_flags, self._context.mode) + with suppress(PermissionError): # This locked is not owned by this UID + os.fchmod(fd, self._context.mode) + try: + fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB) + except OSError as exception: + os.close(fd) + if exception.errno == ENOSYS: # NotImplemented error + msg = "FileSystem does not appear to support flock; use SoftFileLock instead" + raise NotImplementedError(msg) from exception + else: + self._context.lock_file_fd = fd + + def _release(self) -> None: + # Do not remove the lockfile: + # https://github.com/tox-dev/py-filelock/issues/31 + # https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition + fd = cast("int", self._context.lock_file_fd) + self._context.lock_file_fd = None + fcntl.flock(fd, fcntl.LOCK_UN) + os.close(fd) + + +__all__ = [ + "UnixFileLock", + "has_fcntl", +] diff --git a/.venv/lib/python3.12/site-packages/fsspec/compression.py b/.venv/lib/python3.12/site-packages/fsspec/compression.py new file mode 100644 index 0000000000000000000000000000000000000000..e21da562bbab49c2ad60e9d9beb546af8dadea45 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/fsspec/compression.py @@ -0,0 +1,182 @@ +"""Helper functions for a standard streaming compression API""" + +from zipfile import ZipFile + +import fsspec.utils +from fsspec.spec import AbstractBufferedFile + + +def noop_file(file, mode, **kwargs): + return file + + +# TODO: files should also be available as contexts +# should be functions of the form func(infile, mode=, **kwargs) -> file-like +compr = {None: noop_file} + + +def register_compression(name, callback, extensions, force=False): + """Register an "inferable" file compression type. + + Registers transparent file compression type for use with fsspec.open. + Compression can be specified by name in open, or "infer"-ed for any files + ending with the given extensions. + + Args: + name: (str) The compression type name. Eg. "gzip". + callback: A callable of form (infile, mode, **kwargs) -> file-like. + Accepts an input file-like object, the target mode and kwargs. + Returns a wrapped file-like object. + extensions: (str, Iterable[str]) A file extension, or list of file + extensions for which to infer this compression scheme. Eg. "gz". + force: (bool) Force re-registration of compression type or extensions. + + Raises: + ValueError: If name or extensions already registered, and not force. + + """ + if isinstance(extensions, str): + extensions = [extensions] + + # Validate registration + if name in compr and not force: + raise ValueError(f"Duplicate compression registration: {name}") + + for ext in extensions: + if ext in fsspec.utils.compressions and not force: + raise ValueError(f"Duplicate compression file extension: {ext} ({name})") + + compr[name] = callback + + for ext in extensions: + fsspec.utils.compressions[ext] = name + + +def unzip(infile, mode="rb", filename=None, **kwargs): + if "r" not in mode: + filename = filename or "file" + z = ZipFile(infile, mode="w", **kwargs) + fo = z.open(filename, mode="w") + fo.close = lambda closer=fo.close: closer() or z.close() + return fo + z = ZipFile(infile) + if filename is None: + filename = z.namelist()[0] + return z.open(filename, mode="r", **kwargs) + + +register_compression("zip", unzip, "zip") + +try: + from bz2 import BZ2File +except ImportError: + pass +else: + register_compression("bz2", BZ2File, "bz2") + +try: # pragma: no cover + from isal import igzip + + def isal(infile, mode="rb", **kwargs): + return igzip.IGzipFile(fileobj=infile, mode=mode, **kwargs) + + register_compression("gzip", isal, "gz") +except ImportError: + from gzip import GzipFile + + register_compression( + "gzip", lambda f, **kwargs: GzipFile(fileobj=f, **kwargs), "gz" + ) + +try: + from lzma import LZMAFile + + register_compression("lzma", LZMAFile, "lzma") + register_compression("xz", LZMAFile, "xz") +except ImportError: + pass + +try: + import lzmaffi + + register_compression("lzma", lzmaffi.LZMAFile, "lzma", force=True) + register_compression("xz", lzmaffi.LZMAFile, "xz", force=True) +except ImportError: + pass + + +class SnappyFile(AbstractBufferedFile): + def __init__(self, infile, mode, **kwargs): + import snappy + + super().__init__( + fs=None, path="snappy", mode=mode.strip("b") + "b", size=999999999, **kwargs + ) + self.infile = infile + if "r" in mode: + self.codec = snappy.StreamDecompressor() + else: + self.codec = snappy.StreamCompressor() + + def _upload_chunk(self, final=False): + self.buffer.seek(0) + out = self.codec.add_chunk(self.buffer.read()) + self.infile.write(out) + return True + + def seek(self, loc, whence=0): + raise NotImplementedError("SnappyFile is not seekable") + + def seekable(self): + return False + + def _fetch_range(self, start, end): + """Get the specified set of bytes from remote""" + data = self.infile.read(end - start) + return self.codec.decompress(data) + + +try: + import snappy + + snappy.compress(b"") + # Snappy may use the .sz file extension, but this is not part of the + # standard implementation. + register_compression("snappy", SnappyFile, []) + +except (ImportError, NameError, AttributeError): + pass + +try: + import lz4.frame + + register_compression("lz4", lz4.frame.open, "lz4") +except ImportError: + pass + +try: + # zstd in the standard library for python >= 3.14 + from compression.zstd import ZstdFile + + register_compression("zstd", ZstdFile, "zst") + +except ImportError: + try: + import zstandard as zstd + + def zstandard_file(infile, mode="rb"): + if "r" in mode: + cctx = zstd.ZstdDecompressor() + return cctx.stream_reader(infile) + else: + cctx = zstd.ZstdCompressor(level=10) + return cctx.stream_writer(infile) + + register_compression("zstd", zstandard_file, "zst") + except ImportError: + pass + + +def available_compressions(): + """Return a list of the implemented compressions.""" + return list(compr) diff --git a/.venv/lib/python3.12/site-packages/fsspec/exceptions.py b/.venv/lib/python3.12/site-packages/fsspec/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..ae8905475f02655f4fc5863931d99ca9da55db78 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/fsspec/exceptions.py @@ -0,0 +1,18 @@ +""" +fsspec user-defined exception classes +""" + +import asyncio + + +class BlocksizeMismatchError(ValueError): + """ + Raised when a cached file is opened with a different blocksize than it was + written with + """ + + +class FSTimeoutError(asyncio.TimeoutError): + """ + Raised when a fsspec function timed out occurs + """ diff --git a/.venv/lib/python3.12/site-packages/markupsafe/_speedups.c b/.venv/lib/python3.12/site-packages/markupsafe/_speedups.c new file mode 100644 index 0000000000000000000000000000000000000000..09dd57caa8c364f431b4fe6cbf37d4cc3172687e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/markupsafe/_speedups.c @@ -0,0 +1,204 @@ +#include + +#define GET_DELTA(inp, inp_end, delta) \ + while (inp < inp_end) { \ + switch (*inp++) { \ + case '"': \ + case '\'': \ + case '&': \ + delta += 4; \ + break; \ + case '<': \ + case '>': \ + delta += 3; \ + break; \ + } \ + } + +#define DO_ESCAPE(inp, inp_end, outp) \ + { \ + Py_ssize_t ncopy = 0; \ + while (inp < inp_end) { \ + switch (*inp) { \ + case '"': \ + memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \ + outp += ncopy; ncopy = 0; \ + *outp++ = '&'; \ + *outp++ = '#'; \ + *outp++ = '3'; \ + *outp++ = '4'; \ + *outp++ = ';'; \ + break; \ + case '\'': \ + memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \ + outp += ncopy; ncopy = 0; \ + *outp++ = '&'; \ + *outp++ = '#'; \ + *outp++ = '3'; \ + *outp++ = '9'; \ + *outp++ = ';'; \ + break; \ + case '&': \ + memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \ + outp += ncopy; ncopy = 0; \ + *outp++ = '&'; \ + *outp++ = 'a'; \ + *outp++ = 'm'; \ + *outp++ = 'p'; \ + *outp++ = ';'; \ + break; \ + case '<': \ + memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \ + outp += ncopy; ncopy = 0; \ + *outp++ = '&'; \ + *outp++ = 'l'; \ + *outp++ = 't'; \ + *outp++ = ';'; \ + break; \ + case '>': \ + memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \ + outp += ncopy; ncopy = 0; \ + *outp++ = '&'; \ + *outp++ = 'g'; \ + *outp++ = 't'; \ + *outp++ = ';'; \ + break; \ + default: \ + ncopy++; \ + } \ + inp++; \ + } \ + memcpy(outp, inp-ncopy, sizeof(*outp)*ncopy); \ + } + +static PyObject* +escape_unicode_kind1(PyUnicodeObject *in) +{ + Py_UCS1 *inp = PyUnicode_1BYTE_DATA(in); + Py_UCS1 *inp_end = inp + PyUnicode_GET_LENGTH(in); + Py_UCS1 *outp; + PyObject *out; + Py_ssize_t delta = 0; + + GET_DELTA(inp, inp_end, delta); + if (!delta) { + Py_INCREF(in); + return (PyObject*)in; + } + + out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, + PyUnicode_IS_ASCII(in) ? 127 : 255); + if (!out) + return NULL; + + inp = PyUnicode_1BYTE_DATA(in); + outp = PyUnicode_1BYTE_DATA(out); + DO_ESCAPE(inp, inp_end, outp); + return out; +} + +static PyObject* +escape_unicode_kind2(PyUnicodeObject *in) +{ + Py_UCS2 *inp = PyUnicode_2BYTE_DATA(in); + Py_UCS2 *inp_end = inp + PyUnicode_GET_LENGTH(in); + Py_UCS2 *outp; + PyObject *out; + Py_ssize_t delta = 0; + + GET_DELTA(inp, inp_end, delta); + if (!delta) { + Py_INCREF(in); + return (PyObject*)in; + } + + out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 65535); + if (!out) + return NULL; + + inp = PyUnicode_2BYTE_DATA(in); + outp = PyUnicode_2BYTE_DATA(out); + DO_ESCAPE(inp, inp_end, outp); + return out; +} + + +static PyObject* +escape_unicode_kind4(PyUnicodeObject *in) +{ + Py_UCS4 *inp = PyUnicode_4BYTE_DATA(in); + Py_UCS4 *inp_end = inp + PyUnicode_GET_LENGTH(in); + Py_UCS4 *outp; + PyObject *out; + Py_ssize_t delta = 0; + + GET_DELTA(inp, inp_end, delta); + if (!delta) { + Py_INCREF(in); + return (PyObject*)in; + } + + out = PyUnicode_New(PyUnicode_GET_LENGTH(in) + delta, 1114111); + if (!out) + return NULL; + + inp = PyUnicode_4BYTE_DATA(in); + outp = PyUnicode_4BYTE_DATA(out); + DO_ESCAPE(inp, inp_end, outp); + return out; +} + +static PyObject* +escape_unicode(PyObject *self, PyObject *s) +{ + if (!PyUnicode_Check(s)) + return NULL; + + // This check is no longer needed in Python 3.12. + if (PyUnicode_READY(s)) + return NULL; + + switch (PyUnicode_KIND(s)) { + case PyUnicode_1BYTE_KIND: + return escape_unicode_kind1((PyUnicodeObject*) s); + case PyUnicode_2BYTE_KIND: + return escape_unicode_kind2((PyUnicodeObject*) s); + case PyUnicode_4BYTE_KIND: + return escape_unicode_kind4((PyUnicodeObject*) s); + } + assert(0); /* shouldn't happen */ + return NULL; +} + +static PyMethodDef module_methods[] = { + {"_escape_inner", (PyCFunction)escape_unicode, METH_O, NULL}, + {NULL, NULL, 0, NULL} /* Sentinel */ +}; + +static struct PyModuleDef module_definition = { + PyModuleDef_HEAD_INIT, + "markupsafe._speedups", + NULL, + -1, + module_methods, + NULL, + NULL, + NULL, + NULL +}; + +PyMODINIT_FUNC +PyInit__speedups(void) +{ + PyObject *m = PyModule_Create(&module_definition); + + if (m == NULL) { + return NULL; + } + + #ifdef Py_GIL_DISABLED + PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED); + #endif + + return m; +} diff --git a/.venv/lib/python3.12/site-packages/markupsafe/_speedups.pyi b/.venv/lib/python3.12/site-packages/markupsafe/_speedups.pyi new file mode 100644 index 0000000000000000000000000000000000000000..8c8885852a26eba90d3ca1783beca535d4d43bb0 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/markupsafe/_speedups.pyi @@ -0,0 +1 @@ +def _escape_inner(s: str, /) -> str: ... diff --git a/.venv/lib/python3.12/site-packages/markupsafe/py.typed b/.venv/lib/python3.12/site-packages/markupsafe/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/METADATA b/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..98acd814861037e65d72b4ababd2e0e8b86555ab --- /dev/null +++ b/.venv/lib/python3.12/site-packages/networkx-3.6.1.dist-info/METADATA @@ -0,0 +1,177 @@ +Metadata-Version: 2.4 +Name: networkx +Version: 3.6.1 +Summary: Python package for creating and manipulating graphs and networks +Author-email: Aric Hagberg +Maintainer-email: NetworkX Developers +License-Expression: BSD-3-Clause +Project-URL: Homepage, https://networkx.org/ +Project-URL: Bug Tracker, https://github.com/networkx/networkx/issues +Project-URL: Documentation, https://networkx.org/documentation/stable/ +Project-URL: Source Code, https://github.com/networkx/networkx +Keywords: Networks,Graph Theory,Mathematics,network,graph,discrete mathematics,math +Platform: Linux +Platform: Mac OSX +Platform: Windows +Platform: Unix +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Science/Research +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: Scientific/Engineering :: Bio-Informatics +Classifier: Topic :: Scientific/Engineering :: Information Analysis +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Physics +Requires-Python: !=3.14.1,>=3.11 +Description-Content-Type: text/x-rst +License-File: LICENSE.txt +Provides-Extra: benchmarking +Requires-Dist: asv; extra == "benchmarking" +Requires-Dist: virtualenv; extra == "benchmarking" +Provides-Extra: default +Requires-Dist: numpy>=1.25; extra == "default" +Requires-Dist: scipy>=1.11.2; extra == "default" +Requires-Dist: matplotlib>=3.8; extra == "default" +Requires-Dist: pandas>=2.0; extra == "default" +Provides-Extra: developer +Requires-Dist: pre-commit>=4.1; extra == "developer" +Requires-Dist: mypy>=1.15; extra == "developer" +Provides-Extra: doc +Requires-Dist: sphinx>=8.0; extra == "doc" +Requires-Dist: pydata-sphinx-theme>=0.16; extra == "doc" +Requires-Dist: sphinx-gallery>=0.18; extra == "doc" +Requires-Dist: numpydoc>=1.8.0; extra == "doc" +Requires-Dist: pillow>=10; extra == "doc" +Requires-Dist: texext>=0.6.7; extra == "doc" +Requires-Dist: myst-nb>=1.1; extra == "doc" +Requires-Dist: intersphinx-registry; extra == "doc" +Provides-Extra: example +Requires-Dist: osmnx>=2.0.0; extra == "example" +Requires-Dist: momepy>=0.7.2; extra == "example" +Requires-Dist: contextily>=1.6; extra == "example" +Requires-Dist: seaborn>=0.13; extra == "example" +Requires-Dist: cairocffi>=1.7; extra == "example" +Requires-Dist: igraph>=0.11; extra == "example" +Requires-Dist: scikit-learn>=1.5; extra == "example" +Requires-Dist: iplotx>=0.9.0; extra == "example" +Provides-Extra: extra +Requires-Dist: lxml>=4.6; extra == "extra" +Requires-Dist: pygraphviz>=1.14; extra == "extra" +Requires-Dist: pydot>=3.0.1; extra == "extra" +Requires-Dist: sympy>=1.10; extra == "extra" +Provides-Extra: release +Requires-Dist: build>=0.10; extra == "release" +Requires-Dist: twine>=4.0; extra == "release" +Requires-Dist: wheel>=0.40; extra == "release" +Requires-Dist: changelist==0.5; extra == "release" +Provides-Extra: test +Requires-Dist: pytest>=7.2; extra == "test" +Requires-Dist: pytest-cov>=4.0; extra == "test" +Requires-Dist: pytest-xdist>=3.0; extra == "test" +Provides-Extra: test-extras +Requires-Dist: pytest-mpl; extra == "test-extras" +Requires-Dist: pytest-randomly; extra == "test-extras" +Dynamic: license-file + +NetworkX +======== + + +.. image:: + https://github.com/networkx/networkx/actions/workflows/test.yml/badge.svg?branch=main + :target: https://github.com/networkx/networkx/actions/workflows/test.yml + +.. image:: + https://img.shields.io/pypi/v/networkx.svg? + :target: https://pypi.python.org/pypi/networkx + +.. image:: + https://img.shields.io/pypi/l/networkx.svg? + :target: https://github.com/networkx/networkx/blob/main/LICENSE.txt + +.. image:: + https://img.shields.io/pypi/pyversions/networkx.svg? + :target: https://pypi.python.org/pypi/networkx + +.. image:: + https://img.shields.io/github/labels/networkx/networkx/good%20first%20issue?color=green&label=contribute + :target: https://github.com/networkx/networkx/contribute + +.. image:: + https://insights.linuxfoundation.org/api/badge/health-score?project=networkx + :target: https://insights.linuxfoundation.org/project/networkx + + +NetworkX is a Python package for the creation, manipulation, +and study of the structure, dynamics, and functions +of complex networks. + +- **Website (including documentation):** https://networkx.org +- **Mailing list:** https://groups.google.com/forum/#!forum/networkx-discuss +- **Source:** https://github.com/networkx/networkx +- **Bug reports:** https://github.com/networkx/networkx/issues +- **Report a security vulnerability:** https://tidelift.com/security +- **Tutorial:** https://networkx.org/documentation/latest/tutorial.html +- **GitHub Discussions:** https://github.com/networkx/networkx/discussions +- **Discord (Scientific Python) invite link:** https://discord.com/invite/vur45CbwMz +- **NetworkX meetings calendar (open to all):** https://scientific-python.org/calendars/networkx.ics + +Simple example +-------------- + +Find the shortest path between two nodes in an undirected graph: + +.. code:: pycon + + >>> import networkx as nx + >>> G = nx.Graph() + >>> G.add_edge("A", "B", weight=4) + >>> G.add_edge("B", "D", weight=2) + >>> G.add_edge("A", "C", weight=3) + >>> G.add_edge("C", "D", weight=4) + >>> nx.shortest_path(G, "A", "D", weight="weight") + ['A', 'B', 'D'] + +Install +------- + +Install the latest released version of NetworkX: + +.. code:: shell + + $ pip install networkx + +Install with all optional dependencies: + +.. code:: shell + + $ pip install networkx[default] + +For additional details, +please see the `installation guide `_. + +Bugs +---- + +Please report any bugs that you find `here `_. +Or, even better, fork the repository on `GitHub `_ +and create a pull request (PR). We welcome all changes, big or small, and we +will help you make the PR if you are new to `git` (just ask on the issue and/or +see the `contributor guide `_). + +License +------- + +Released under the `3-clause BSD license `_:: + + Copyright (c) 2004-2025, NetworkX Developers + Aric Hagberg + Dan Schult + Pieter Swart diff --git a/.venv/lib/python3.12/site-packages/numpy-2.3.5.dist-info/METADATA b/.venv/lib/python3.12/site-packages/numpy-2.3.5.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..f9e7a39ee51177add7d7a106fec0cf571e181c85 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy-2.3.5.dist-info/METADATA @@ -0,0 +1,1093 @@ +Metadata-Version: 2.1 +Name: numpy +Version: 2.3.5 +Summary: Fundamental package for array computing in Python +Author: Travis E. Oliphant et al. +Maintainer-Email: NumPy Developers +License: Copyright (c) 2005-2025, NumPy Developers. + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + + * Neither the name of the NumPy Developers nor the names of any + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + ---- + + The NumPy repository and source distributions bundle several libraries that are + compatibly licensed. We list these here. + + Name: lapack-lite + Files: numpy/linalg/lapack_lite/* + License: BSD-3-Clause + For details, see numpy/linalg/lapack_lite/LICENSE.txt + + Name: dragon4 + Files: numpy/_core/src/multiarray/dragon4.c + License: MIT + For license text, see numpy/_core/src/multiarray/dragon4.c + + Name: libdivide + Files: numpy/_core/include/numpy/libdivide/* + License: Zlib + For license text, see numpy/_core/include/numpy/libdivide/LICENSE.txt + + + Note that the following files are vendored in the repository and sdist but not + installed in built numpy packages: + + Name: Meson + Files: vendored-meson/meson/* + License: Apache 2.0 + For license text, see vendored-meson/meson/COPYING + + Name: spin + Files: .spin/cmds.py + License: BSD-3 + For license text, see .spin/LICENSE + + Name: tempita + Files: numpy/_build_utils/tempita/* + License: MIT + For details, see numpy/_build_utils/tempita/LICENCE.txt + + ---- + + This binary distribution of NumPy also bundles the following software: + + + Name: OpenBLAS + Files: numpy.libs/libscipy_openblas*.so + Description: bundled as a dynamically linked library + Availability: https://github.com/OpenMathLib/OpenBLAS/ + License: BSD-3-Clause + Copyright (c) 2011-2014, The OpenBLAS Project + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + 3. Neither the name of the OpenBLAS project nor the names of + its contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + Name: LAPACK + Files: numpy.libs/libscipy_openblas*.so + Description: bundled in OpenBLAS + Availability: https://github.com/OpenMathLib/OpenBLAS/ + License: BSD-3-Clause-Open-MPI + Copyright (c) 1992-2013 The University of Tennessee and The University + of Tennessee Research Foundation. All rights + reserved. + Copyright (c) 2000-2013 The University of California Berkeley. All + rights reserved. + Copyright (c) 2006-2013 The University of Colorado Denver. All rights + reserved. + + $COPYRIGHT$ + + Additional copyrights may follow + + $HEADER$ + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + - Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + - Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer listed + in this license in the documentation and/or other materials + provided with the distribution. + + - Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + + The copyright holders provide no reassurances that the source code + provided does not infringe any patent, copyright, or any other + intellectual property rights of third parties. The copyright holders + disclaim any liability to any recipient for claims brought against + recipient by any third party for infringement of that parties + intellectual property rights. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + + Name: GCC runtime library + Files: numpy.libs/libgfortran*.so + Description: dynamically linked to files compiled with gcc + Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libgfortran + License: GPL-3.0-or-later WITH GCC-exception-3.1 + Copyright (C) 2002-2017 Free Software Foundation, Inc. + + Libgfortran is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + Libgfortran is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + Under Section 7 of GPL version 3, you are granted additional + permissions described in the GCC Runtime Library Exception, version + 3.1, as published by the Free Software Foundation. + + You should have received a copy of the GNU General Public License and + a copy of the GCC Runtime Library Exception along with this program; + see the files COPYING3 and COPYING.RUNTIME respectively. If not, see + . + + ---- + + Full text of license texts referred to above follows (that they are + listed below does not necessarily imply the conditions apply to the + present binary release): + + ---- + + GCC RUNTIME LIBRARY EXCEPTION + + Version 3.1, 31 March 2009 + + Copyright (C) 2009 Free Software Foundation, Inc. + + Everyone is permitted to copy and distribute verbatim copies of this + license document, but changing it is not allowed. + + This GCC Runtime Library Exception ("Exception") is an additional + permission under section 7 of the GNU General Public License, version + 3 ("GPLv3"). It applies to a given file (the "Runtime Library") that + bears a notice placed by the copyright holder of the file stating that + the file is governed by GPLv3 along with this Exception. + + When you use GCC to compile a program, GCC may combine portions of + certain GCC header files and runtime libraries with the compiled + program. The purpose of this Exception is to allow compilation of + non-GPL (including proprietary) programs to use, in this way, the + header files and runtime libraries covered by this Exception. + + 0. Definitions. + + A file is an "Independent Module" if it either requires the Runtime + Library for execution after a Compilation Process, or makes use of an + interface provided by the Runtime Library, but is not otherwise based + on the Runtime Library. + + "GCC" means a version of the GNU Compiler Collection, with or without + modifications, governed by version 3 (or a specified later version) of + the GNU General Public License (GPL) with the option of using any + subsequent versions published by the FSF. + + "GPL-compatible Software" is software whose conditions of propagation, + modification and use would permit combination with GCC in accord with + the license of GCC. + + "Target Code" refers to output from any compiler for a real or virtual + target processor architecture, in executable form or suitable for + input to an assembler, loader, linker and/or execution + phase. Notwithstanding that, Target Code does not include data in any + format that is used as a compiler intermediate representation, or used + for producing a compiler intermediate representation. + + The "Compilation Process" transforms code entirely represented in + non-intermediate languages designed for human-written code, and/or in + Java Virtual Machine byte code, into Target Code. Thus, for example, + use of source code generators and preprocessors need not be considered + part of the Compilation Process, since the Compilation Process can be + understood as starting with the output of the generators or + preprocessors. + + A Compilation Process is "Eligible" if it is done using GCC, alone or + with other GPL-compatible software, or if it is done without using any + work based on GCC. For example, using non-GPL-compatible Software to + optimize any GCC intermediate representations would not qualify as an + Eligible Compilation Process. + + 1. Grant of Additional Permission. + + You have permission to propagate a work of Target Code formed by + combining the Runtime Library with Independent Modules, even if such + propagation would otherwise violate the terms of GPLv3, provided that + all Target Code was generated by Eligible Compilation Processes. You + may then convey such a combination under terms of your choice, + consistent with the licensing of the Independent Modules. + + 2. No Weakening of GCC Copyleft. + + The availability of this Exception does not imply any general + presumption that third-party software is unaffected by the copyleft + requirements of the license of GCC. + + ---- + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for + software and other kinds of works. + + The licenses for most software and other practical works are designed + to take away your freedom to share and change the works. By contrast, + the GNU General Public License is intended to guarantee your freedom to + share and change all versions of a program--to make sure it remains free + software for all its users. We, the Free Software Foundation, use the + GNU General Public License for most of our software; it applies also to + any other work released this way by its authors. You can apply it to + your programs, too. + + When we speak of free software, we are referring to freedom, not + price. Our General Public Licenses are designed to make sure that you + have the freedom to distribute copies of free software (and charge for + them if you wish), that you receive source code or can get it if you + want it, that you can change the software or use pieces of it in new + free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you + these rights or asking you to surrender the rights. Therefore, you have + certain responsibilities if you distribute copies of the software, or if + you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether + gratis or for a fee, you must pass on to the recipients the same + freedoms that you received. You must make sure that they, too, receive + or can get the source code. And you must show them these terms so they + know their rights. + + Developers that use the GNU GPL protect your rights with two steps: + (1) assert copyright on the software, and (2) offer you this License + giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains + that there is no warranty for this free software. For both users' and + authors' sake, the GPL requires that modified versions be marked as + changed, so that their problems will not be attributed erroneously to + authors of previous versions. + + Some devices are designed to deny users access to install or run + modified versions of the software inside them, although the manufacturer + can do so. This is fundamentally incompatible with the aim of + protecting users' freedom to change the software. The systematic + pattern of such abuse occurs in the area of products for individuals to + use, which is precisely where it is most unacceptable. Therefore, we + have designed this version of the GPL to prohibit the practice for those + products. If such problems arise substantially in other domains, we + stand ready to extend this provision to those domains in future versions + of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. + States should not allow patents to restrict development and use of + software on general-purpose computers, but in those that do, we wish to + avoid the special danger that patents applied to a free program could + make it effectively proprietary. To prevent this, the GPL assures that + patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and + modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of + works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this + License. Each licensee is addressed as "you". "Licensees" and + "recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work + in a fashion requiring copyright permission, other than the making of an + exact copy. The resulting work is called a "modified version" of the + earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based + on the Program. + + To "propagate" a work means to do anything with it that, without + permission, would make you directly or secondarily liable for + infringement under applicable copyright law, except executing it on a + computer or modifying a private copy. Propagation includes copying, + distribution (with or without modification), making available to the + public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other + parties to make or receive copies. Mere interaction with a user through + a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" + to the extent that it includes a convenient and prominently visible + feature that (1) displays an appropriate copyright notice, and (2) + tells the user that there is no warranty for the work (except to the + extent that warranties are provided), that licensees may convey the + work under this License, and how to view a copy of this License. If + the interface presents a list of user commands or options, such as a + menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work + for making modifications to it. "Object code" means any non-source + form of a work. + + A "Standard Interface" means an interface that either is an official + standard defined by a recognized standards body, or, in the case of + interfaces specified for a particular programming language, one that + is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other + than the work as a whole, that (a) is included in the normal form of + packaging a Major Component, but which is not part of that Major + Component, and (b) serves only to enable use of the work with that + Major Component, or to implement a Standard Interface for which an + implementation is available to the public in source code form. A + "Major Component", in this context, means a major essential component + (kernel, window system, and so on) of the specific operating system + (if any) on which the executable work runs, or a compiler used to + produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all + the source code needed to generate, install, and (for an executable + work) run the object code and to modify the work, including scripts to + control those activities. However, it does not include the work's + System Libraries, or general-purpose tools or generally available free + programs which are used unmodified in performing those activities but + which are not part of the work. For example, Corresponding Source + includes interface definition files associated with source files for + the work, and the source code for shared libraries and dynamically + linked subprograms that the work is specifically designed to require, + such as by intimate data communication or control flow between those + subprograms and other parts of the work. + + The Corresponding Source need not include anything that users + can regenerate automatically from other parts of the Corresponding + Source. + + The Corresponding Source for a work in source code form is that + same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of + copyright on the Program, and are irrevocable provided the stated + conditions are met. This License explicitly affirms your unlimited + permission to run the unmodified Program. The output from running a + covered work is covered by this License only if the output, given its + content, constitutes a covered work. This License acknowledges your + rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not + convey, without conditions so long as your license otherwise remains + in force. You may convey covered works to others for the sole purpose + of having them make modifications exclusively for you, or provide you + with facilities for running those works, provided that you comply with + the terms of this License in conveying all material for which you do + not control copyright. Those thus making or running the covered works + for you must do so exclusively on your behalf, under your direction + and control, on terms that prohibit them from making any copies of + your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under + the conditions stated below. Sublicensing is not allowed; section 10 + makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological + measure under any applicable law fulfilling obligations under article + 11 of the WIPO copyright treaty adopted on 20 December 1996, or + similar laws prohibiting or restricting circumvention of such + measures. + + When you convey a covered work, you waive any legal power to forbid + circumvention of technological measures to the extent such circumvention + is effected by exercising rights under this License with respect to + the covered work, and you disclaim any intention to limit operation or + modification of the work as a means of enforcing, against the work's + users, your or third parties' legal rights to forbid circumvention of + technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you + receive it, in any medium, provided that you conspicuously and + appropriately publish on each copy an appropriate copyright notice; + keep intact all notices stating that this License and any + non-permissive terms added in accord with section 7 apply to the code; + keep intact all notices of the absence of any warranty; and give all + recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, + and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to + produce it from the Program, in the form of source code under the + terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent + works, which are not by their nature extensions of the covered work, + and which are not combined with it such as to form a larger program, + in or on a volume of a storage or distribution medium, is called an + "aggregate" if the compilation and its resulting copyright are not + used to limit the access or legal rights of the compilation's users + beyond what the individual works permit. Inclusion of a covered work + in an aggregate does not cause this License to apply to the other + parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms + of sections 4 and 5, provided that you also convey the + machine-readable Corresponding Source under the terms of this License, + in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded + from the Corresponding Source as a System Library, need not be + included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any + tangible personal property which is normally used for personal, family, + or household purposes, or (2) anything designed or sold for incorporation + into a dwelling. In determining whether a product is a consumer product, + doubtful cases shall be resolved in favor of coverage. For a particular + product received by a particular user, "normally used" refers to a + typical or common use of that class of product, regardless of the status + of the particular user or of the way in which the particular user + actually uses, or expects or is expected to use, the product. A product + is a consumer product regardless of whether the product has substantial + commercial, industrial or non-consumer uses, unless such uses represent + the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, + procedures, authorization keys, or other information required to install + and execute modified versions of a covered work in that User Product from + a modified version of its Corresponding Source. The information must + suffice to ensure that the continued functioning of the modified object + code is in no case prevented or interfered with solely because + modification has been made. + + If you convey an object code work under this section in, or with, or + specifically for use in, a User Product, and the conveying occurs as + part of a transaction in which the right of possession and use of the + User Product is transferred to the recipient in perpetuity or for a + fixed term (regardless of how the transaction is characterized), the + Corresponding Source conveyed under this section must be accompanied + by the Installation Information. But this requirement does not apply + if neither you nor any third party retains the ability to install + modified object code on the User Product (for example, the work has + been installed in ROM). + + The requirement to provide Installation Information does not include a + requirement to continue to provide support service, warranty, or updates + for a work that has been modified or installed by the recipient, or for + the User Product in which it has been modified or installed. Access to a + network may be denied when the modification itself materially and + adversely affects the operation of the network or violates the rules and + protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, + in accord with this section must be in a format that is publicly + documented (and with an implementation available to the public in + source code form), and must require no special password or key for + unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this + License by making exceptions from one or more of its conditions. + Additional permissions that are applicable to the entire Program shall + be treated as though they were included in this License, to the extent + that they are valid under applicable law. If additional permissions + apply only to part of the Program, that part may be used separately + under those permissions, but the entire Program remains governed by + this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option + remove any additional permissions from that copy, or from any part of + it. (Additional permissions may be written to require their own + removal in certain cases when you modify the work.) You may place + additional permissions on material, added by you to a covered work, + for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you + add to a covered work, you may (if authorized by the copyright holders of + that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further + restrictions" within the meaning of section 10. If the Program as you + received it, or any part of it, contains a notice stating that it is + governed by this License along with a term that is a further + restriction, you may remove that term. If a license document contains + a further restriction but permits relicensing or conveying under this + License, you may add to a covered work material governed by the terms + of that license document, provided that the further restriction does + not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you + must place, in the relevant source files, a statement of the + additional terms that apply to those files, or a notice indicating + where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the + form of a separately written license, or stated as exceptions; + the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly + provided under this License. Any attempt otherwise to propagate or + modify it is void, and will automatically terminate your rights under + this License (including any patent licenses granted under the third + paragraph of section 11). + + However, if you cease all violation of this License, then your + license from a particular copyright holder is reinstated (a) + provisionally, unless and until the copyright holder explicitly and + finally terminates your license, and (b) permanently, if the copyright + holder fails to notify you of the violation by some reasonable means + prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is + reinstated permanently if the copyright holder notifies you of the + violation by some reasonable means, this is the first time you have + received notice of violation of this License (for any work) from that + copyright holder, and you cure the violation prior to 30 days after + your receipt of the notice. + + Termination of your rights under this section does not terminate the + licenses of parties who have received copies or rights from you under + this License. If your rights have been terminated and not permanently + reinstated, you do not qualify to receive new licenses for the same + material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or + run a copy of the Program. Ancillary propagation of a covered work + occurring solely as a consequence of using peer-to-peer transmission + to receive a copy likewise does not require acceptance. However, + nothing other than this License grants you permission to propagate or + modify any covered work. These actions infringe copyright if you do + not accept this License. Therefore, by modifying or propagating a + covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically + receives a license from the original licensors, to run, modify and + propagate that work, subject to this License. You are not responsible + for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an + organization, or substantially all assets of one, or subdividing an + organization, or merging organizations. If propagation of a covered + work results from an entity transaction, each party to that + transaction who receives a copy of the work also receives whatever + licenses to the work the party's predecessor in interest had or could + give under the previous paragraph, plus a right to possession of the + Corresponding Source of the work from the predecessor in interest, if + the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the + rights granted or affirmed under this License. For example, you may + not impose a license fee, royalty, or other charge for exercise of + rights granted under this License, and you may not initiate litigation + (including a cross-claim or counterclaim in a lawsuit) alleging that + any patent claim is infringed by making, using, selling, offering for + sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this + License of the Program or a work on which the Program is based. The + work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims + owned or controlled by the contributor, whether already acquired or + hereafter acquired, that would be infringed by some manner, permitted + by this License, of making, using, or selling its contributor version, + but do not include claims that would be infringed only as a + consequence of further modification of the contributor version. For + purposes of this definition, "control" includes the right to grant + patent sublicenses in a manner consistent with the requirements of + this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free + patent license under the contributor's essential patent claims, to + make, use, sell, offer for sale, import and otherwise run, modify and + propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express + agreement or commitment, however denominated, not to enforce a patent + (such as an express permission to practice a patent or covenant not to + sue for patent infringement). To "grant" such a patent license to a + party means to make such an agreement or commitment not to enforce a + patent against the party. + + If you convey a covered work, knowingly relying on a patent license, + and the Corresponding Source of the work is not available for anyone + to copy, free of charge and under the terms of this License, through a + publicly available network server or other readily accessible means, + then you must either (1) cause the Corresponding Source to be so + available, or (2) arrange to deprive yourself of the benefit of the + patent license for this particular work, or (3) arrange, in a manner + consistent with the requirements of this License, to extend the patent + license to downstream recipients. "Knowingly relying" means you have + actual knowledge that, but for the patent license, your conveying the + covered work in a country, or your recipient's use of the covered work + in a country, would infringe one or more identifiable patents in that + country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or + arrangement, you convey, or propagate by procuring conveyance of, a + covered work, and grant a patent license to some of the parties + receiving the covered work authorizing them to use, propagate, modify + or convey a specific copy of the covered work, then the patent license + you grant is automatically extended to all recipients of the covered + work and works based on it. + + A patent license is "discriminatory" if it does not include within + the scope of its coverage, prohibits the exercise of, or is + conditioned on the non-exercise of one or more of the rights that are + specifically granted under this License. You may not convey a covered + work if you are a party to an arrangement with a third party that is + in the business of distributing software, under which you make payment + to the third party based on the extent of your activity of conveying + the work, and under which the third party grants, to any of the + parties who would receive the covered work from you, a discriminatory + patent license (a) in connection with copies of the covered work + conveyed by you (or copies made from those copies), or (b) primarily + for and in connection with specific products or compilations that + contain the covered work, unless you entered into that arrangement, + or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting + any implied license or other defenses to infringement that may + otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or + otherwise) that contradict the conditions of this License, they do not + excuse you from the conditions of this License. If you cannot convey a + covered work so as to satisfy simultaneously your obligations under this + License and any other pertinent obligations, then as a consequence you may + not convey it at all. For example, if you agree to terms that obligate you + to collect a royalty for further conveying from those to whom you convey + the Program, the only way you could satisfy both those terms and this + License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have + permission to link or combine any covered work with a work licensed + under version 3 of the GNU Affero General Public License into a single + combined work, and to convey the resulting work. The terms of this + License will continue to apply to the part which is the covered work, + but the special requirements of the GNU Affero General Public License, + section 13, concerning interaction through a network will apply to the + combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of + the GNU General Public License from time to time. Such new versions will + be similar in spirit to the present version, but may differ in detail to + address new problems or concerns. + + Each version is given a distinguishing version number. If the + Program specifies that a certain numbered version of the GNU General + Public License "or any later version" applies to it, you have the + option of following the terms and conditions either of that numbered + version or of any later version published by the Free Software + Foundation. If the Program does not specify a version number of the + GNU General Public License, you may choose any version ever published + by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future + versions of the GNU General Public License can be used, that proxy's + public statement of acceptance of a version permanently authorizes you + to choose that version for the Program. + + Later license versions may give you additional or different + permissions. However, no additional obligations are imposed on any + author or copyright holder as a result of your choosing to follow a + later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY + APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT + HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY + OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, + THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM + IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF + ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING + WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS + THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY + GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE + USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF + DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD + PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), + EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF + SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided + above cannot be given local legal effect according to their terms, + reviewing courts shall apply local law that most closely approximates + an absolute waiver of all civil liability in connection with the + Program, unless a warranty or assumption of liability accompanies a + copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest + possible use to the public, the best way to achieve this is to make it + free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest + to attach them to the start of each source file to most effectively + state the exclusion of warranty; and each file should have at least + the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + + Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short + notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + + The hypothetical commands `show w' and `show c' should show the appropriate + parts of the General Public License. Of course, your program's commands + might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, + if any, to sign a "copyright disclaimer" for the program, if necessary. + For more information on this, and how to apply and follow the GNU GPL, see + . + + The GNU General Public License does not permit incorporating your program + into proprietary programs. If your program is a subroutine library, you + may consider it more useful to permit linking proprietary applications with + the library. If this is what you want to do, use the GNU Lesser General + Public License instead of this License. But first, please read + . + + Name: libquadmath + Files: numpy.libs/libquadmath*.so + Description: dynamically linked to files compiled with gcc + Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libquadmath + License: LGPL-2.1-or-later + + GCC Quad-Precision Math Library + Copyright (C) 2010-2019 Free Software Foundation, Inc. + Written by Francois-Xavier Coudert + + This file is part of the libquadmath library. + Libquadmath is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + Libquadmath is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + https://www.gnu.org/licenses/old-licenses/lgpl-2.1.html + +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Science/Research +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: C +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: 3.13 +Classifier: Programming Language :: Python :: 3.14 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Topic :: Software Development +Classifier: Topic :: Scientific/Engineering +Classifier: Typing :: Typed +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX +Classifier: Operating System :: Unix +Classifier: Operating System :: MacOS +Project-URL: homepage, https://numpy.org +Project-URL: documentation, https://numpy.org/doc/ +Project-URL: source, https://github.com/numpy/numpy +Project-URL: download, https://pypi.org/project/numpy/#files +Project-URL: tracker, https://github.com/numpy/numpy/issues +Project-URL: release notes, https://numpy.org/doc/stable/release +Requires-Python: >=3.11 +Description-Content-Type: text/markdown + +

+ +


+ + +[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)]( +https://numfocus.org) +[![PyPI Downloads](https://img.shields.io/pypi/dm/numpy.svg?label=PyPI%20downloads)]( +https://pypi.org/project/numpy/) +[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/numpy.svg?label=Conda%20downloads)]( +https://anaconda.org/conda-forge/numpy) +[![Stack Overflow](https://img.shields.io/badge/stackoverflow-Ask%20questions-blue.svg)]( +https://stackoverflow.com/questions/tagged/numpy) +[![Nature Paper](https://img.shields.io/badge/DOI-10.1038%2Fs41586--020--2649--2-blue)]( +https://doi.org/10.1038/s41586-020-2649-2) +[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/numpy/numpy/badge)](https://securityscorecards.dev/viewer/?uri=github.com/numpy/numpy) +[![Typing](https://img.shields.io/pypi/types/numpy)](https://pypi.org/project/numpy/) + + +NumPy is the fundamental package for scientific computing with Python. + +- **Website:** https://numpy.org +- **Documentation:** https://numpy.org/doc +- **Mailing list:** https://mail.python.org/mailman/listinfo/numpy-discussion +- **Source code:** https://github.com/numpy/numpy +- **Contributing:** https://numpy.org/devdocs/dev/index.html +- **Bug reports:** https://github.com/numpy/numpy/issues +- **Report a security vulnerability:** https://tidelift.com/docs/security + +It provides: + +- a powerful N-dimensional array object +- sophisticated (broadcasting) functions +- tools for integrating C/C++ and Fortran code +- useful linear algebra, Fourier transform, and random number capabilities + +Testing: + +NumPy requires `pytest` and `hypothesis`. Tests can then be run after installation with: + + python -c "import numpy, sys; sys.exit(numpy.test() is False)" + +Code of Conduct +---------------------- + +NumPy is a community-driven open source project developed by a diverse group of +[contributors](https://numpy.org/teams/). The NumPy leadership has made a strong +commitment to creating an open, inclusive, and positive community. Please read the +[NumPy Code of Conduct](https://numpy.org/code-of-conduct/) for guidance on how to interact +with others in a way that makes our community thrive. + +Call for Contributions +---------------------- + +The NumPy project welcomes your expertise and enthusiasm! + +Small improvements or fixes are always appreciated. If you are considering larger contributions +to the source code, please contact us through the [mailing +list](https://mail.python.org/mailman/listinfo/numpy-discussion) first. + +Writing code isn’t the only way to contribute to NumPy. You can also: +- review pull requests +- help us stay on top of new and old issues +- develop tutorials, presentations, and other educational materials +- maintain and improve [our website](https://github.com/numpy/numpy.org) +- develop graphic design for our brand assets and promotional materials +- translate website content +- help with outreach and onboard new contributors +- write grant proposals and help with other fundraising efforts + +For more information about the ways you can contribute to NumPy, visit [our website](https://numpy.org/contribute/). +If you’re unsure where to start or how your skills fit in, reach out! You can +ask on the mailing list or here, on GitHub, by opening a new issue or leaving a +comment on a relevant issue that is already open. + +Our preferred channels of communication are all public, but if you’d like to +speak to us in private first, contact our community coordinators at +numpy-team@googlegroups.com or on Slack (write numpy-team@googlegroups.com for +an invitation). + +We also have a biweekly community call, details of which are announced on the +mailing list. You are very welcome to join. + +If you are new to contributing to open source, [this +guide](https://opensource.guide/how-to-contribute/) helps explain why, what, +and how to successfully get involved. diff --git a/.venv/lib/python3.12/site-packages/numpy/__config__.pyi b/.venv/lib/python3.12/site-packages/numpy/__config__.pyi new file mode 100644 index 0000000000000000000000000000000000000000..b59bdcd252b633a4bf07245f9b32f23d7283ba69 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/__config__.pyi @@ -0,0 +1,102 @@ +from enum import Enum +from types import ModuleType +from typing import Final, NotRequired, TypedDict, overload, type_check_only +from typing import Literal as L + +_CompilerConfigDictValue = TypedDict( + "_CompilerConfigDictValue", + { + "name": str, + "linker": str, + "version": str, + "commands": str, + "args": str, + "linker args": str, + }, +) +_CompilerConfigDict = TypedDict( + "_CompilerConfigDict", + { + "c": _CompilerConfigDictValue, + "cython": _CompilerConfigDictValue, + "c++": _CompilerConfigDictValue, + }, +) +_MachineInformationDict = TypedDict( + "_MachineInformationDict", + { + "host": _MachineInformationDictValue, + "build": _MachineInformationDictValue, + "cross-compiled": NotRequired[L[True]], + }, +) + +@type_check_only +class _MachineInformationDictValue(TypedDict): + cpu: str + family: str + endian: L["little", "big"] + system: str + +_BuildDependenciesDictValue = TypedDict( + "_BuildDependenciesDictValue", + { + "name": str, + "found": NotRequired[L[True]], + "version": str, + "include directory": str, + "lib directory": str, + "openblas configuration": str, + "pc file directory": str, + }, +) + +class _BuildDependenciesDict(TypedDict): + blas: _BuildDependenciesDictValue + lapack: _BuildDependenciesDictValue + +class _PythonInformationDict(TypedDict): + path: str + version: str + +_SIMDExtensionsDict = TypedDict( + "_SIMDExtensionsDict", + { + "baseline": list[str], + "found": list[str], + "not found": list[str], + }, +) + +_ConfigDict = TypedDict( + "_ConfigDict", + { + "Compilers": _CompilerConfigDict, + "Machine Information": _MachineInformationDict, + "Build Dependencies": _BuildDependenciesDict, + "Python Information": _PythonInformationDict, + "SIMD Extensions": _SIMDExtensionsDict, + }, +) + +### + +__all__ = ["show_config"] + +CONFIG: Final[_ConfigDict] = ... + +class DisplayModes(Enum): + stdout = "stdout" + dicts = "dicts" + +def _check_pyyaml() -> ModuleType: ... + +@overload +def show(mode: L["stdout"] = "stdout") -> None: ... +@overload +def show(mode: L["dicts"]) -> _ConfigDict: ... + +@overload +def show_config(mode: L["stdout"] = "stdout") -> None: ... +@overload +def show_config(mode: L["dicts"]) -> _ConfigDict: ... diff --git a/.venv/lib/python3.12/site-packages/numpy/__init__.py b/.venv/lib/python3.12/site-packages/numpy/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..097fe9f414ecc739cf8da6617cb813aeab1fd693 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/__init__.py @@ -0,0 +1,945 @@ +""" +NumPy +===== + +Provides + 1. An array object of arbitrary homogeneous items + 2. Fast mathematical operations over arrays + 3. Linear Algebra, Fourier Transforms, Random Number Generation + +How to use the documentation +---------------------------- +Documentation is available in two forms: docstrings provided +with the code, and a loose standing reference guide, available from +`the NumPy homepage `_. + +We recommend exploring the docstrings using +`IPython `_, an advanced Python shell with +TAB-completion and introspection capabilities. See below for further +instructions. + +The docstring examples assume that `numpy` has been imported as ``np``:: + + >>> import numpy as np + +Code snippets are indicated by three greater-than signs:: + + >>> x = 42 + >>> x = x + 1 + +Use the built-in ``help`` function to view a function's docstring:: + + >>> help(np.sort) + ... # doctest: +SKIP + +For some objects, ``np.info(obj)`` may provide additional help. This is +particularly true if you see the line "Help on ufunc object:" at the top +of the help() page. Ufuncs are implemented in C, not Python, for speed. +The native Python help() does not know how to view their help, but our +np.info() function does. + +Available subpackages +--------------------- +lib + Basic functions used by several sub-packages. +random + Core Random Tools +linalg + Core Linear Algebra Tools +fft + Core FFT routines +polynomial + Polynomial tools +testing + NumPy testing tools +distutils + Enhancements to distutils with support for + Fortran compilers support and more (for Python <= 3.11) + +Utilities +--------- +test + Run numpy unittests +show_config + Show numpy build configuration +__version__ + NumPy version string + +Viewing documentation using IPython +----------------------------------- + +Start IPython and import `numpy` usually under the alias ``np``: `import +numpy as np`. Then, directly past or use the ``%cpaste`` magic to paste +examples into the shell. To see which functions are available in `numpy`, +type ``np.`` (where ```` refers to the TAB key), or use +``np.*cos*?`` (where ```` refers to the ENTER key) to narrow +down the list. To view the docstring for a function, use +``np.cos?`` (to view the docstring) and ``np.cos??`` (to view +the source code). + +Copies vs. in-place operation +----------------------------- +Most of the functions in `numpy` return a copy of the array argument +(e.g., `np.sort`). In-place versions of these functions are often +available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``. +Exceptions to this rule are documented. + +""" +import os +import sys +import warnings + +# If a version with git hash was stored, use that instead +from . import version +from ._expired_attrs_2_0 import __expired_attributes__ +from ._globals import _CopyMode, _NoValue +from .version import __version__ + +# We first need to detect if we're being called as part of the numpy setup +# procedure itself in a reliable manner. +try: + __NUMPY_SETUP__ # noqa: B018 +except NameError: + __NUMPY_SETUP__ = False + +if __NUMPY_SETUP__: + sys.stderr.write('Running from numpy source directory.\n') +else: + # Allow distributors to run custom init code before importing numpy._core + from . import _distributor_init + + try: + from numpy.__config__ import show_config + except ImportError as e: + msg = """Error importing numpy: you should not try to import numpy from + its source directory; please exit the numpy source tree, and relaunch + your python interpreter from there.""" + raise ImportError(msg) from e + + from . import _core + from ._core import ( + False_, + ScalarType, + True_, + abs, + absolute, + acos, + acosh, + add, + all, + allclose, + amax, + amin, + any, + arange, + arccos, + arccosh, + arcsin, + arcsinh, + arctan, + arctan2, + arctanh, + argmax, + argmin, + argpartition, + argsort, + argwhere, + around, + array, + array2string, + array_equal, + array_equiv, + array_repr, + array_str, + asanyarray, + asarray, + ascontiguousarray, + asfortranarray, + asin, + asinh, + astype, + atan, + atan2, + atanh, + atleast_1d, + atleast_2d, + atleast_3d, + base_repr, + binary_repr, + bitwise_and, + bitwise_count, + bitwise_invert, + bitwise_left_shift, + bitwise_not, + bitwise_or, + bitwise_right_shift, + bitwise_xor, + block, + bool, + bool_, + broadcast, + busday_count, + busday_offset, + busdaycalendar, + byte, + bytes_, + can_cast, + cbrt, + cdouble, + ceil, + character, + choose, + clip, + clongdouble, + complex64, + complex128, + complexfloating, + compress, + concat, + concatenate, + conj, + conjugate, + convolve, + copysign, + copyto, + correlate, + cos, + cosh, + count_nonzero, + cross, + csingle, + cumprod, + cumsum, + cumulative_prod, + cumulative_sum, + datetime64, + datetime_as_string, + datetime_data, + deg2rad, + degrees, + diagonal, + divide, + divmod, + dot, + double, + dtype, + e, + einsum, + einsum_path, + empty, + empty_like, + equal, + errstate, + euler_gamma, + exp, + exp2, + expm1, + fabs, + finfo, + flatiter, + flatnonzero, + flexible, + float16, + float32, + float64, + float_power, + floating, + floor, + floor_divide, + fmax, + fmin, + fmod, + format_float_positional, + format_float_scientific, + frexp, + from_dlpack, + frombuffer, + fromfile, + fromfunction, + fromiter, + frompyfunc, + fromstring, + full, + full_like, + gcd, + generic, + geomspace, + get_printoptions, + getbufsize, + geterr, + geterrcall, + greater, + greater_equal, + half, + heaviside, + hstack, + hypot, + identity, + iinfo, + indices, + inexact, + inf, + inner, + int8, + int16, + int32, + int64, + int_, + intc, + integer, + intp, + invert, + is_busday, + isclose, + isdtype, + isfinite, + isfortran, + isinf, + isnan, + isnat, + isscalar, + issubdtype, + lcm, + ldexp, + left_shift, + less, + less_equal, + lexsort, + linspace, + little_endian, + log, + log1p, + log2, + log10, + logaddexp, + logaddexp2, + logical_and, + logical_not, + logical_or, + logical_xor, + logspace, + long, + longdouble, + longlong, + matmul, + matrix_transpose, + matvec, + max, + maximum, + may_share_memory, + mean, + memmap, + min, + min_scalar_type, + minimum, + mod, + modf, + moveaxis, + multiply, + nan, + ndarray, + ndim, + nditer, + negative, + nested_iters, + newaxis, + nextafter, + nonzero, + not_equal, + number, + object_, + ones, + ones_like, + outer, + partition, + permute_dims, + pi, + positive, + pow, + power, + printoptions, + prod, + promote_types, + ptp, + put, + putmask, + rad2deg, + radians, + ravel, + recarray, + reciprocal, + record, + remainder, + repeat, + require, + reshape, + resize, + result_type, + right_shift, + rint, + roll, + rollaxis, + round, + sctypeDict, + searchsorted, + set_printoptions, + setbufsize, + seterr, + seterrcall, + shape, + shares_memory, + short, + sign, + signbit, + signedinteger, + sin, + single, + sinh, + size, + sort, + spacing, + sqrt, + square, + squeeze, + stack, + std, + str_, + subtract, + sum, + swapaxes, + take, + tan, + tanh, + tensordot, + timedelta64, + trace, + transpose, + true_divide, + trunc, + typecodes, + ubyte, + ufunc, + uint, + uint8, + uint16, + uint32, + uint64, + uintc, + uintp, + ulong, + ulonglong, + unsignedinteger, + unstack, + ushort, + var, + vdot, + vecdot, + vecmat, + void, + vstack, + where, + zeros, + zeros_like, + ) + + # NOTE: It's still under discussion whether these aliases + # should be removed. + for ta in ["float96", "float128", "complex192", "complex256"]: + try: + globals()[ta] = getattr(_core, ta) + except AttributeError: + pass + del ta + + from . import lib + from . import matrixlib as _mat + from .lib import scimath as emath + from .lib._arraypad_impl import pad + from .lib._arraysetops_impl import ( + ediff1d, + in1d, + intersect1d, + isin, + setdiff1d, + setxor1d, + union1d, + unique, + unique_all, + unique_counts, + unique_inverse, + unique_values, + ) + from .lib._function_base_impl import ( + angle, + append, + asarray_chkfinite, + average, + bartlett, + bincount, + blackman, + copy, + corrcoef, + cov, + delete, + diff, + digitize, + extract, + flip, + gradient, + hamming, + hanning, + i0, + insert, + interp, + iterable, + kaiser, + median, + meshgrid, + percentile, + piecewise, + place, + quantile, + rot90, + select, + sinc, + sort_complex, + trapezoid, + trapz, + trim_zeros, + unwrap, + vectorize, + ) + from .lib._histograms_impl import histogram, histogram_bin_edges, histogramdd + from .lib._index_tricks_impl import ( + c_, + diag_indices, + diag_indices_from, + fill_diagonal, + index_exp, + ix_, + mgrid, + ndenumerate, + ndindex, + ogrid, + r_, + ravel_multi_index, + s_, + unravel_index, + ) + from .lib._nanfunctions_impl import ( + nanargmax, + nanargmin, + nancumprod, + nancumsum, + nanmax, + nanmean, + nanmedian, + nanmin, + nanpercentile, + nanprod, + nanquantile, + nanstd, + nansum, + nanvar, + ) + from .lib._npyio_impl import ( + fromregex, + genfromtxt, + load, + loadtxt, + packbits, + save, + savetxt, + savez, + savez_compressed, + unpackbits, + ) + from .lib._polynomial_impl import ( + poly, + poly1d, + polyadd, + polyder, + polydiv, + polyfit, + polyint, + polymul, + polysub, + polyval, + roots, + ) + from .lib._shape_base_impl import ( + apply_along_axis, + apply_over_axes, + array_split, + column_stack, + dsplit, + dstack, + expand_dims, + hsplit, + kron, + put_along_axis, + row_stack, + split, + take_along_axis, + tile, + vsplit, + ) + from .lib._stride_tricks_impl import ( + broadcast_arrays, + broadcast_shapes, + broadcast_to, + ) + from .lib._twodim_base_impl import ( + diag, + diagflat, + eye, + fliplr, + flipud, + histogram2d, + mask_indices, + tri, + tril, + tril_indices, + tril_indices_from, + triu, + triu_indices, + triu_indices_from, + vander, + ) + from .lib._type_check_impl import ( + common_type, + imag, + iscomplex, + iscomplexobj, + isreal, + isrealobj, + mintypecode, + nan_to_num, + real, + real_if_close, + typename, + ) + from .lib._ufunclike_impl import fix, isneginf, isposinf + from .lib._utils_impl import get_include, info, show_runtime + from .matrixlib import asmatrix, bmat, matrix + + # public submodules are imported lazily, therefore are accessible from + # __getattr__. Note that `distutils` (deprecated) and `array_api` + # (experimental label) are not added here, because `from numpy import *` + # must not raise any warnings - that's too disruptive. + __numpy_submodules__ = { + "linalg", "fft", "dtypes", "random", "polynomial", "ma", + "exceptions", "lib", "ctypeslib", "testing", "typing", + "f2py", "test", "rec", "char", "core", "strings", + } + + # We build warning messages for former attributes + _msg = ( + "module 'numpy' has no attribute '{n}'.\n" + "`np.{n}` was a deprecated alias for the builtin `{n}`. " + "To avoid this error in existing code, use `{n}` by itself. " + "Doing this will not modify any behavior and is safe. {extended_msg}\n" + "The aliases was originally deprecated in NumPy 1.20; for more " + "details and guidance see the original release note at:\n" + " https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations") + + _specific_msg = ( + "If you specifically wanted the numpy scalar type, use `np.{}` here.") + + _int_extended_msg = ( + "When replacing `np.{}`, you may wish to use e.g. `np.int64` " + "or `np.int32` to specify the precision. If you wish to review " + "your current use, check the release note link for " + "additional information.") + + _type_info = [ + ("object", ""), # The NumPy scalar only exists by name. + ("float", _specific_msg.format("float64")), + ("complex", _specific_msg.format("complex128")), + ("str", _specific_msg.format("str_")), + ("int", _int_extended_msg.format("int"))] + + __former_attrs__ = { + n: _msg.format(n=n, extended_msg=extended_msg) + for n, extended_msg in _type_info + } + + # Some of these could be defined right away, but most were aliases to + # the Python objects and only removed in NumPy 1.24. Defining them should + # probably wait for NumPy 1.26 or 2.0. + # When defined, these should possibly not be added to `__all__` to avoid + # import with `from numpy import *`. + __future_scalars__ = {"str", "bytes", "object"} + + __array_api_version__ = "2024.12" + + from ._array_api_info import __array_namespace_info__ + + # now that numpy core module is imported, can initialize limits + _core.getlimits._register_known_types() + + __all__ = list( + __numpy_submodules__ | + set(_core.__all__) | + set(_mat.__all__) | + set(lib._histograms_impl.__all__) | + set(lib._nanfunctions_impl.__all__) | + set(lib._function_base_impl.__all__) | + set(lib._twodim_base_impl.__all__) | + set(lib._shape_base_impl.__all__) | + set(lib._type_check_impl.__all__) | + set(lib._arraysetops_impl.__all__) | + set(lib._ufunclike_impl.__all__) | + set(lib._arraypad_impl.__all__) | + set(lib._utils_impl.__all__) | + set(lib._stride_tricks_impl.__all__) | + set(lib._polynomial_impl.__all__) | + set(lib._npyio_impl.__all__) | + set(lib._index_tricks_impl.__all__) | + {"emath", "show_config", "__version__", "__array_namespace_info__"} + ) + + # Filter out Cython harmless warnings + warnings.filterwarnings("ignore", message="numpy.dtype size changed") + warnings.filterwarnings("ignore", message="numpy.ufunc size changed") + warnings.filterwarnings("ignore", message="numpy.ndarray size changed") + + def __getattr__(attr): + # Warn for expired attributes + import warnings + + if attr == "linalg": + import numpy.linalg as linalg + return linalg + elif attr == "fft": + import numpy.fft as fft + return fft + elif attr == "dtypes": + import numpy.dtypes as dtypes + return dtypes + elif attr == "random": + import numpy.random as random + return random + elif attr == "polynomial": + import numpy.polynomial as polynomial + return polynomial + elif attr == "ma": + import numpy.ma as ma + return ma + elif attr == "ctypeslib": + import numpy.ctypeslib as ctypeslib + return ctypeslib + elif attr == "exceptions": + import numpy.exceptions as exceptions + return exceptions + elif attr == "testing": + import numpy.testing as testing + return testing + elif attr == "matlib": + import numpy.matlib as matlib + return matlib + elif attr == "f2py": + import numpy.f2py as f2py + return f2py + elif attr == "typing": + import numpy.typing as typing + return typing + elif attr == "rec": + import numpy.rec as rec + return rec + elif attr == "char": + import numpy.char as char + return char + elif attr == "array_api": + raise AttributeError("`numpy.array_api` is not available from " + "numpy 2.0 onwards", name=None) + elif attr == "core": + import numpy.core as core + return core + elif attr == "strings": + import numpy.strings as strings + return strings + elif attr == "distutils": + if 'distutils' in __numpy_submodules__: + import numpy.distutils as distutils + return distutils + else: + raise AttributeError("`numpy.distutils` is not available from " + "Python 3.12 onwards", name=None) + + if attr in __future_scalars__: + # And future warnings for those that will change, but also give + # the AttributeError + warnings.warn( + f"In the future `np.{attr}` will be defined as the " + "corresponding NumPy scalar.", FutureWarning, stacklevel=2) + + if attr in __former_attrs__: + raise AttributeError(__former_attrs__[attr], name=None) + + if attr in __expired_attributes__: + raise AttributeError( + f"`np.{attr}` was removed in the NumPy 2.0 release. " + f"{__expired_attributes__[attr]}", + name=None + ) + + if attr == "chararray": + warnings.warn( + "`np.chararray` is deprecated and will be removed from " + "the main namespace in the future. Use an array with a string " + "or bytes dtype instead.", DeprecationWarning, stacklevel=2) + import numpy.char as char + return char.chararray + + raise AttributeError(f"module {__name__!r} has no attribute {attr!r}") + + def __dir__(): + public_symbols = ( + globals().keys() | __numpy_submodules__ + ) + public_symbols -= { + "matrixlib", "matlib", "tests", "conftest", "version", + "distutils", "array_api" + } + return list(public_symbols) + + # Pytest testing + from numpy._pytesttester import PytestTester + test = PytestTester(__name__) + del PytestTester + + def _sanity_check(): + """ + Quick sanity checks for common bugs caused by environment. + There are some cases e.g. with wrong BLAS ABI that cause wrong + results under specific runtime conditions that are not necessarily + achieved during test suite runs, and it is useful to catch those early. + + See https://github.com/numpy/numpy/issues/8577 and other + similar bug reports. + + """ + try: + x = ones(2, dtype=float32) + if not abs(x.dot(x) - float32(2.0)) < 1e-5: + raise AssertionError + except AssertionError: + msg = ("The current Numpy installation ({!r}) fails to " + "pass simple sanity checks. This can be caused for example " + "by incorrect BLAS library being linked in, or by mixing " + "package managers (pip, conda, apt, ...). Search closed " + "numpy issues for similar problems.") + raise RuntimeError(msg.format(__file__)) from None + + _sanity_check() + del _sanity_check + + def _mac_os_check(): + """ + Quick Sanity check for Mac OS look for accelerate build bugs. + Testing numpy polyfit calls init_dgelsd(LAPACK) + """ + try: + c = array([3., 2., 1.]) + x = linspace(0, 2, 5) + y = polyval(c, x) + _ = polyfit(x, y, 2, cov=True) + except ValueError: + pass + + if sys.platform == "darwin": + from . import exceptions + with warnings.catch_warnings(record=True) as w: + _mac_os_check() + # Throw runtime error, if the test failed + # Check for warning and report the error_message + if len(w) > 0: + for _wn in w: + if _wn.category is exceptions.RankWarning: + # Ignore other warnings, they may not be relevant (see gh-25433) + error_message = ( + f"{_wn.category.__name__}: {_wn.message}" + ) + msg = ( + "Polyfit sanity test emitted a warning, most likely due " + "to using a buggy Accelerate backend." + "\nIf you compiled yourself, more information is available at:" # noqa: E501 + "\nhttps://numpy.org/devdocs/building/index.html" + "\nOtherwise report this to the vendor " + f"that provided NumPy.\n\n{error_message}\n") + raise RuntimeError(msg) + del _wn + del w + del _mac_os_check + + def blas_fpe_check(): + # Check if BLAS adds spurious FPEs, mostly seen on M4 arms with Accelerate. + with errstate(all='raise'): + x = ones((20, 20)) + try: + x @ x + except FloatingPointError: + res = _core._multiarray_umath._blas_supports_fpe(False) + if res: # res was not modified (hardcoded to True for now) + warnings.warn( + "Spurious warnings given by blas but suppression not " + "set up on this platform. Please open a NumPy issue.", + UserWarning, stacklevel=2) + + blas_fpe_check() + del blas_fpe_check + + def hugepage_setup(): + """ + We usually use madvise hugepages support, but on some old kernels it + is slow and thus better avoided. Specifically kernel version 4.6 + had a bug fix which probably fixed this: + https://github.com/torvalds/linux/commit/7cf91a98e607c2f935dbcc177d70011e95b8faff + """ + use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None) + if sys.platform == "linux" and use_hugepage is None: + # If there is an issue with parsing the kernel version, + # set use_hugepage to 0. Usage of LooseVersion will handle + # the kernel version parsing better, but avoided since it + # will increase the import time. + # See: #16679 for related discussion. + try: + use_hugepage = 1 + kernel_version = os.uname().release.split(".")[:2] + kernel_version = tuple(int(v) for v in kernel_version) + if kernel_version < (4, 6): + use_hugepage = 0 + except ValueError: + use_hugepage = 0 + elif use_hugepage is None: + # This is not Linux, so it should not matter, just enable anyway + use_hugepage = 1 + else: + use_hugepage = int(use_hugepage) + return use_hugepage + + # Note that this will currently only make a difference on Linux + _core.multiarray._set_madvise_hugepage(hugepage_setup()) + del hugepage_setup + + # Give a warning if NumPy is reloaded or imported on a sub-interpreter + # We do this from python, since the C-module may not be reloaded and + # it is tidier organized. + _core.multiarray._multiarray_umath._reload_guard() + + # TODO: Remove the environment variable entirely now that it is "weak" + if (os.environ.get("NPY_PROMOTION_STATE", "weak") != "weak"): + warnings.warn( + "NPY_PROMOTION_STATE was a temporary feature for NumPy 2.0 " + "transition and is ignored after NumPy 2.2.", + UserWarning, stacklevel=2) + + # Tell PyInstaller where to find hook-numpy.py + def _pyinstaller_hooks_dir(): + from pathlib import Path + return [str(Path(__file__).with_name("_pyinstaller").resolve())] + + +# Remove symbols imported for internal use +del os, sys, warnings diff --git a/.venv/lib/python3.12/site-packages/numpy/_array_api_info.pyi b/.venv/lib/python3.12/site-packages/numpy/_array_api_info.pyi new file mode 100644 index 0000000000000000000000000000000000000000..ee9f8a5660c3a72cda2266b0238a5a50c36de8fd --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/_array_api_info.pyi @@ -0,0 +1,207 @@ +from typing import ( + ClassVar, + Literal, + Never, + TypeAlias, + TypedDict, + TypeVar, + final, + overload, + type_check_only, +) + +import numpy as np + +_Device: TypeAlias = Literal["cpu"] +_DeviceLike: TypeAlias = _Device | None + +_Capabilities = TypedDict( + "_Capabilities", + { + "boolean indexing": Literal[True], + "data-dependent shapes": Literal[True], + }, +) + +_DefaultDTypes = TypedDict( + "_DefaultDTypes", + { + "real floating": np.dtype[np.float64], + "complex floating": np.dtype[np.complex128], + "integral": np.dtype[np.intp], + "indexing": np.dtype[np.intp], + }, +) + +_KindBool: TypeAlias = Literal["bool"] +_KindInt: TypeAlias = Literal["signed integer"] +_KindUInt: TypeAlias = Literal["unsigned integer"] +_KindInteger: TypeAlias = Literal["integral"] +_KindFloat: TypeAlias = Literal["real floating"] +_KindComplex: TypeAlias = Literal["complex floating"] +_KindNumber: TypeAlias = Literal["numeric"] +_Kind: TypeAlias = ( + _KindBool + | _KindInt + | _KindUInt + | _KindInteger + | _KindFloat + | _KindComplex + | _KindNumber +) + +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T3 = TypeVar("_T3") +_Permute1: TypeAlias = _T1 | tuple[_T1] +_Permute2: TypeAlias = tuple[_T1, _T2] | tuple[_T2, _T1] +_Permute3: TypeAlias = ( + tuple[_T1, _T2, _T3] | tuple[_T1, _T3, _T2] + | tuple[_T2, _T1, _T3] | tuple[_T2, _T3, _T1] + | tuple[_T3, _T1, _T2] | tuple[_T3, _T2, _T1] +) + +@type_check_only +class _DTypesBool(TypedDict): + bool: np.dtype[np.bool] + +@type_check_only +class _DTypesInt(TypedDict): + int8: np.dtype[np.int8] + int16: np.dtype[np.int16] + int32: np.dtype[np.int32] + int64: np.dtype[np.int64] + +@type_check_only +class _DTypesUInt(TypedDict): + uint8: np.dtype[np.uint8] + uint16: np.dtype[np.uint16] + uint32: np.dtype[np.uint32] + uint64: np.dtype[np.uint64] + +@type_check_only +class _DTypesInteger(_DTypesInt, _DTypesUInt): ... + +@type_check_only +class _DTypesFloat(TypedDict): + float32: np.dtype[np.float32] + float64: np.dtype[np.float64] + +@type_check_only +class _DTypesComplex(TypedDict): + complex64: np.dtype[np.complex64] + complex128: np.dtype[np.complex128] + +@type_check_only +class _DTypesNumber(_DTypesInteger, _DTypesFloat, _DTypesComplex): ... + +@type_check_only +class _DTypes(_DTypesBool, _DTypesNumber): ... + +@type_check_only +class _DTypesUnion(TypedDict, total=False): + bool: np.dtype[np.bool] + int8: np.dtype[np.int8] + int16: np.dtype[np.int16] + int32: np.dtype[np.int32] + int64: np.dtype[np.int64] + uint8: np.dtype[np.uint8] + uint16: np.dtype[np.uint16] + uint32: np.dtype[np.uint32] + uint64: np.dtype[np.uint64] + float32: np.dtype[np.float32] + float64: np.dtype[np.float64] + complex64: np.dtype[np.complex64] + complex128: np.dtype[np.complex128] + +_EmptyDict: TypeAlias = dict[Never, Never] + +@final +class __array_namespace_info__: + __module__: ClassVar[Literal['numpy']] + + def capabilities(self) -> _Capabilities: ... + def default_device(self) -> _Device: ... + def default_dtypes( + self, + *, + device: _DeviceLike = ..., + ) -> _DefaultDTypes: ... + def devices(self) -> list[_Device]: ... + + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: None = ..., + ) -> _DTypes: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindBool], + ) -> _DTypesBool: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindInt], + ) -> _DTypesInt: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindUInt], + ) -> _DTypesUInt: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindFloat], + ) -> _DTypesFloat: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: _Permute1[_KindComplex], + ) -> _DTypesComplex: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: ( + _Permute1[_KindInteger] + | _Permute2[_KindInt, _KindUInt] + ), + ) -> _DTypesInteger: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: ( + _Permute1[_KindNumber] + | _Permute3[_KindInteger, _KindFloat, _KindComplex] + ), + ) -> _DTypesNumber: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: tuple[()], + ) -> _EmptyDict: ... + @overload + def dtypes( + self, + *, + device: _DeviceLike = ..., + kind: tuple[_Kind, ...], + ) -> _DTypesUnion: ... diff --git a/.venv/lib/python3.12/site-packages/numpy/_distributor_init.pyi b/.venv/lib/python3.12/site-packages/numpy/_distributor_init.pyi new file mode 100644 index 0000000000000000000000000000000000000000..94456aba2bcfaf1166eeb81199dff4515c8b9474 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/_distributor_init.pyi @@ -0,0 +1 @@ +# intentionally left blank diff --git a/.venv/lib/python3.12/site-packages/numpy/_expired_attrs_2_0.py b/.venv/lib/python3.12/site-packages/numpy/_expired_attrs_2_0.py new file mode 100644 index 0000000000000000000000000000000000000000..1397134e3f8cacb8dfb32683f8ddbcdcbd6d21f4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/_expired_attrs_2_0.py @@ -0,0 +1,79 @@ +""" +Dict of expired attributes that are discontinued since 2.0 release. +Each item is associated with a migration note. +""" + +__expired_attributes__ = { + "geterrobj": "Use the np.errstate context manager instead.", + "seterrobj": "Use the np.errstate context manager instead.", + "cast": "Use `np.asarray(arr, dtype=dtype)` instead.", + "source": "Use `inspect.getsource` instead.", + "lookfor": "Search NumPy's documentation directly.", + "who": "Use an IDE variable explorer or `locals()` instead.", + "fastCopyAndTranspose": "Use `arr.T.copy()` instead.", + "set_numeric_ops": + "For the general case, use `PyUFunc_ReplaceLoopBySignature`. " + "For ndarray subclasses, define the ``__array_ufunc__`` method " + "and override the relevant ufunc.", + "NINF": "Use `-np.inf` instead.", + "PINF": "Use `np.inf` instead.", + "NZERO": "Use `-0.0` instead.", + "PZERO": "Use `0.0` instead.", + "add_newdoc": + "It's still available as `np.lib.add_newdoc`.", + "add_docstring": + "It's still available as `np.lib.add_docstring`.", + "add_newdoc_ufunc": + "It's an internal function and doesn't have a replacement.", + "safe_eval": "Use `ast.literal_eval` instead.", + "float_": "Use `np.float64` instead.", + "complex_": "Use `np.complex128` instead.", + "longfloat": "Use `np.longdouble` instead.", + "singlecomplex": "Use `np.complex64` instead.", + "cfloat": "Use `np.complex128` instead.", + "longcomplex": "Use `np.clongdouble` instead.", + "clongfloat": "Use `np.clongdouble` instead.", + "string_": "Use `np.bytes_` instead.", + "unicode_": "Use `np.str_` instead.", + "Inf": "Use `np.inf` instead.", + "Infinity": "Use `np.inf` instead.", + "NaN": "Use `np.nan` instead.", + "infty": "Use `np.inf` instead.", + "issctype": "Use `issubclass(rep, np.generic)` instead.", + "maximum_sctype": + "Use a specific dtype instead. You should avoid relying " + "on any implicit mechanism and select the largest dtype of " + "a kind explicitly in the code.", + "obj2sctype": "Use `np.dtype(obj).type` instead.", + "sctype2char": "Use `np.dtype(obj).char` instead.", + "sctypes": "Access dtypes explicitly instead.", + "issubsctype": "Use `np.issubdtype` instead.", + "set_string_function": + "Use `np.set_printoptions` instead with a formatter for " + "custom printing of NumPy objects.", + "asfarray": "Use `np.asarray` with a proper dtype instead.", + "issubclass_": "Use `issubclass` builtin instead.", + "tracemalloc_domain": "It's now available from `np.lib`.", + "mat": "Use `np.asmatrix` instead.", + "recfromcsv": "Use `np.genfromtxt` with comma delimiter instead.", + "recfromtxt": "Use `np.genfromtxt` instead.", + "deprecate": "Emit `DeprecationWarning` with `warnings.warn` directly, " + "or use `typing.deprecated`.", + "deprecate_with_doc": "Emit `DeprecationWarning` with `warnings.warn` " + "directly, or use `typing.deprecated`.", + "disp": "Use your own printing function instead.", + "find_common_type": + "Use `numpy.promote_types` or `numpy.result_type` instead. " + "To achieve semantics for the `scalar_types` argument, use " + "`numpy.result_type` and pass the Python values `0`, `0.0`, or `0j`.", + "round_": "Use `np.round` instead.", + "get_array_wrap": "", + "DataSource": "It's still available as `np.lib.npyio.DataSource`.", + "nbytes": "Use `np.dtype().itemsize` instead.", + "byte_bounds": "Now it's available under `np.lib.array_utils.byte_bounds`", + "compare_chararrays": + "It's still available as `np.char.compare_chararrays`.", + "format_parser": "It's still available as `np.rec.format_parser`.", + "alltrue": "Use `np.all` instead.", + "sometrue": "Use `np.any` instead.", +} diff --git a/.venv/lib/python3.12/site-packages/numpy/_globals.pyi b/.venv/lib/python3.12/site-packages/numpy/_globals.pyi new file mode 100644 index 0000000000000000000000000000000000000000..b2231a9636b0863be24555734d66df6da3464ac4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/_globals.pyi @@ -0,0 +1,17 @@ +__all__ = ["_CopyMode", "_NoValue"] + +import enum +from typing import Final, final + +@final +class _CopyMode(enum.Enum): + ALWAYS = True + NEVER = False + IF_NEEDED = 2 + + def __bool__(self, /) -> bool: ... + +@final +class _NoValueType: ... + +_NoValue: Final[_NoValueType] = ... diff --git a/.venv/lib/python3.12/site-packages/numpy/_pytesttester.pyi b/.venv/lib/python3.12/site-packages/numpy/_pytesttester.pyi new file mode 100644 index 0000000000000000000000000000000000000000..a12abb1c1a105b624c9fbb580f2da6a10209bcac --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/_pytesttester.pyi @@ -0,0 +1,18 @@ +from collections.abc import Iterable +from typing import Literal as L + +__all__ = ["PytestTester"] + +class PytestTester: + module_name: str + def __init__(self, module_name: str) -> None: ... + def __call__( + self, + label: L["fast", "full"] = ..., + verbose: int = ..., + extra_argv: Iterable[str] | None = ..., + doctests: L[False] = ..., + coverage: bool = ..., + durations: int = ..., + tests: Iterable[str] | None = ..., + ) -> bool: ... diff --git a/.venv/lib/python3.12/site-packages/numpy/dtypes.py b/.venv/lib/python3.12/site-packages/numpy/dtypes.py new file mode 100644 index 0000000000000000000000000000000000000000..550a29e18f292e65600108804636b833c75d1be4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/dtypes.py @@ -0,0 +1,41 @@ +""" +This module is home to specific dtypes related functionality and their classes. +For more general information about dtypes, also see `numpy.dtype` and +:ref:`arrays.dtypes`. + +Similar to the builtin ``types`` module, this submodule defines types (classes) +that are not widely used directly. + +.. versionadded:: NumPy 1.25 + + The dtypes module is new in NumPy 1.25. Previously DType classes were + only accessible indirectly. + + +DType classes +------------- + +The following are the classes of the corresponding NumPy dtype instances and +NumPy scalar types. The classes can be used in ``isinstance`` checks and can +also be instantiated or used directly. Direct use of these classes is not +typical, since their scalar counterparts (e.g. ``np.float64``) or strings +like ``"float64"`` can be used. +""" + +# See doc/source/reference/routines.dtypes.rst for module-level docs + +__all__ = [] + + +def _add_dtype_helper(DType, alias): + # Function to add DTypes a bit more conveniently without channeling them + # through `numpy._core._multiarray_umath` namespace or similar. + from numpy import dtypes + + setattr(dtypes, DType.__name__, DType) + __all__.append(DType.__name__) + + if alias: + alias = alias.removeprefix("numpy.dtypes.") + setattr(dtypes, alias, DType) + __all__.append(alias) diff --git a/.venv/lib/python3.12/site-packages/numpy/dtypes.pyi b/.venv/lib/python3.12/site-packages/numpy/dtypes.pyi new file mode 100644 index 0000000000000000000000000000000000000000..007dc643c0e308a43e6085a4e4cc0ded24f49fba --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/dtypes.pyi @@ -0,0 +1,631 @@ +# ruff: noqa: ANN401 +from typing import ( + Any, + Generic, + LiteralString, + Never, + NoReturn, + Self, + TypeAlias, + final, + overload, + type_check_only, +) +from typing import Literal as L + +from typing_extensions import TypeVar + +import numpy as np + +__all__ = [ # noqa: RUF022 + 'BoolDType', + 'Int8DType', + 'ByteDType', + 'UInt8DType', + 'UByteDType', + 'Int16DType', + 'ShortDType', + 'UInt16DType', + 'UShortDType', + 'Int32DType', + 'IntDType', + 'UInt32DType', + 'UIntDType', + 'Int64DType', + 'LongDType', + 'UInt64DType', + 'ULongDType', + 'LongLongDType', + 'ULongLongDType', + 'Float16DType', + 'Float32DType', + 'Float64DType', + 'LongDoubleDType', + 'Complex64DType', + 'Complex128DType', + 'CLongDoubleDType', + 'ObjectDType', + 'BytesDType', + 'StrDType', + 'VoidDType', + 'DateTime64DType', + 'TimeDelta64DType', + 'StringDType', +] + +# Helper base classes (typing-only) + +_ScalarT_co = TypeVar("_ScalarT_co", bound=np.generic, covariant=True) + +@type_check_only +class _SimpleDType(np.dtype[_ScalarT_co], Generic[_ScalarT_co]): # type: ignore[misc] # pyright: ignore[reportGeneralTypeIssues] + names: None # pyright: ignore[reportIncompatibleVariableOverride] + def __new__(cls, /) -> Self: ... + def __getitem__(self, key: Any, /) -> NoReturn: ... + @property + def base(self) -> np.dtype[_ScalarT_co]: ... + @property + def fields(self) -> None: ... + @property + def isalignedstruct(self) -> L[False]: ... + @property + def isnative(self) -> L[True]: ... + @property + def ndim(self) -> L[0]: ... + @property + def shape(self) -> tuple[()]: ... + @property + def subdtype(self) -> None: ... + +@type_check_only +class _LiteralDType(_SimpleDType[_ScalarT_co], Generic[_ScalarT_co]): # type: ignore[misc] + @property + def flags(self) -> L[0]: ... + @property + def hasobject(self) -> L[False]: ... + +# Helper mixins (typing-only): + +_KindT_co = TypeVar("_KindT_co", bound=LiteralString, covariant=True) +_CharT_co = TypeVar("_CharT_co", bound=LiteralString, covariant=True) +_NumT_co = TypeVar("_NumT_co", bound=int, covariant=True) + +@type_check_only +class _TypeCodes(Generic[_KindT_co, _CharT_co, _NumT_co]): + @final + @property + def kind(self) -> _KindT_co: ... + @final + @property + def char(self) -> _CharT_co: ... + @final + @property + def num(self) -> _NumT_co: ... + +@type_check_only +class _NoOrder: + @final + @property + def byteorder(self) -> L["|"]: ... + +@type_check_only +class _NativeOrder: + @final + @property + def byteorder(self) -> L["="]: ... + +_DataSize_co = TypeVar("_DataSize_co", bound=int, covariant=True) +_ItemSize_co = TypeVar("_ItemSize_co", bound=int, covariant=True, default=int) + +@type_check_only +class _NBit(Generic[_DataSize_co, _ItemSize_co]): + @final + @property + def alignment(self) -> _DataSize_co: ... + @final + @property + def itemsize(self) -> _ItemSize_co: ... + +@type_check_only +class _8Bit(_NoOrder, _NBit[L[1], L[1]]): ... + +# Boolean: + +@final +class BoolDType( # type: ignore[misc] + _TypeCodes[L["b"], L["?"], L[0]], + _8Bit, + _LiteralDType[np.bool], +): + @property + def name(self) -> L["bool"]: ... + @property + def str(self) -> L["|b1"]: ... + +# Sized integers: + +@final +class Int8DType( # type: ignore[misc] + _TypeCodes[L["i"], L["b"], L[1]], + _8Bit, + _LiteralDType[np.int8], +): + @property + def name(self) -> L["int8"]: ... + @property + def str(self) -> L["|i1"]: ... + +@final +class UInt8DType( # type: ignore[misc] + _TypeCodes[L["u"], L["B"], L[2]], + _8Bit, + _LiteralDType[np.uint8], +): + @property + def name(self) -> L["uint8"]: ... + @property + def str(self) -> L["|u1"]: ... + +@final +class Int16DType( # type: ignore[misc] + _TypeCodes[L["i"], L["h"], L[3]], + _NativeOrder, + _NBit[L[2], L[2]], + _LiteralDType[np.int16], +): + @property + def name(self) -> L["int16"]: ... + @property + def str(self) -> L["i2"]: ... + +@final +class UInt16DType( # type: ignore[misc] + _TypeCodes[L["u"], L["H"], L[4]], + _NativeOrder, + _NBit[L[2], L[2]], + _LiteralDType[np.uint16], +): + @property + def name(self) -> L["uint16"]: ... + @property + def str(self) -> L["u2"]: ... + +@final +class Int32DType( # type: ignore[misc] + _TypeCodes[L["i"], L["i", "l"], L[5, 7]], + _NativeOrder, + _NBit[L[4], L[4]], + _LiteralDType[np.int32], +): + @property + def name(self) -> L["int32"]: ... + @property + def str(self) -> L["i4"]: ... + +@final +class UInt32DType( # type: ignore[misc] + _TypeCodes[L["u"], L["I", "L"], L[6, 8]], + _NativeOrder, + _NBit[L[4], L[4]], + _LiteralDType[np.uint32], +): + @property + def name(self) -> L["uint32"]: ... + @property + def str(self) -> L["u4"]: ... + +@final +class Int64DType( # type: ignore[misc] + _TypeCodes[L["i"], L["l", "q"], L[7, 9]], + _NativeOrder, + _NBit[L[8], L[8]], + _LiteralDType[np.int64], +): + @property + def name(self) -> L["int64"]: ... + @property + def str(self) -> L["i8"]: ... + +@final +class UInt64DType( # type: ignore[misc] + _TypeCodes[L["u"], L["L", "Q"], L[8, 10]], + _NativeOrder, + _NBit[L[8], L[8]], + _LiteralDType[np.uint64], +): + @property + def name(self) -> L["uint64"]: ... + @property + def str(self) -> L["u8"]: ... + +# Standard C-named version/alias: +# NOTE: Don't make these `Final`: it will break stubtest +ByteDType = Int8DType +UByteDType = UInt8DType +ShortDType = Int16DType +UShortDType = UInt16DType + +@final +class IntDType( # type: ignore[misc] + _TypeCodes[L["i"], L["i"], L[5]], + _NativeOrder, + _NBit[L[4], L[4]], + _LiteralDType[np.intc], +): + @property + def name(self) -> L["int32"]: ... + @property + def str(self) -> L["i4"]: ... + +@final +class UIntDType( # type: ignore[misc] + _TypeCodes[L["u"], L["I"], L[6]], + _NativeOrder, + _NBit[L[4], L[4]], + _LiteralDType[np.uintc], +): + @property + def name(self) -> L["uint32"]: ... + @property + def str(self) -> L["u4"]: ... + +@final +class LongDType( # type: ignore[misc] + _TypeCodes[L["i"], L["l"], L[7]], + _NativeOrder, + _NBit[L[4, 8], L[4, 8]], + _LiteralDType[np.long], +): + @property + def name(self) -> L["int32", "int64"]: ... + @property + def str(self) -> L["i4", "i8"]: ... + +@final +class ULongDType( # type: ignore[misc] + _TypeCodes[L["u"], L["L"], L[8]], + _NativeOrder, + _NBit[L[4, 8], L[4, 8]], + _LiteralDType[np.ulong], +): + @property + def name(self) -> L["uint32", "uint64"]: ... + @property + def str(self) -> L["u4", "u8"]: ... + +@final +class LongLongDType( # type: ignore[misc] + _TypeCodes[L["i"], L["q"], L[9]], + _NativeOrder, + _NBit[L[8], L[8]], + _LiteralDType[np.longlong], +): + @property + def name(self) -> L["int64"]: ... + @property + def str(self) -> L["i8"]: ... + +@final +class ULongLongDType( # type: ignore[misc] + _TypeCodes[L["u"], L["Q"], L[10]], + _NativeOrder, + _NBit[L[8], L[8]], + _LiteralDType[np.ulonglong], +): + @property + def name(self) -> L["uint64"]: ... + @property + def str(self) -> L["u8"]: ... + +# Floats: + +@final +class Float16DType( # type: ignore[misc] + _TypeCodes[L["f"], L["e"], L[23]], + _NativeOrder, + _NBit[L[2], L[2]], + _LiteralDType[np.float16], +): + @property + def name(self) -> L["float16"]: ... + @property + def str(self) -> L["f2"]: ... + +@final +class Float32DType( # type: ignore[misc] + _TypeCodes[L["f"], L["f"], L[11]], + _NativeOrder, + _NBit[L[4], L[4]], + _LiteralDType[np.float32], +): + @property + def name(self) -> L["float32"]: ... + @property + def str(self) -> L["f4"]: ... + +@final +class Float64DType( # type: ignore[misc] + _TypeCodes[L["f"], L["d"], L[12]], + _NativeOrder, + _NBit[L[8], L[8]], + _LiteralDType[np.float64], +): + @property + def name(self) -> L["float64"]: ... + @property + def str(self) -> L["f8"]: ... + +@final +class LongDoubleDType( # type: ignore[misc] + _TypeCodes[L["f"], L["g"], L[13]], + _NativeOrder, + _NBit[L[8, 12, 16], L[8, 12, 16]], + _LiteralDType[np.longdouble], +): + @property + def name(self) -> L["float64", "float96", "float128"]: ... + @property + def str(self) -> L["f8", "f12", "f16"]: ... + +# Complex: + +@final +class Complex64DType( # type: ignore[misc] + _TypeCodes[L["c"], L["F"], L[14]], + _NativeOrder, + _NBit[L[4], L[8]], + _LiteralDType[np.complex64], +): + @property + def name(self) -> L["complex64"]: ... + @property + def str(self) -> L["c8"]: ... + +@final +class Complex128DType( # type: ignore[misc] + _TypeCodes[L["c"], L["D"], L[15]], + _NativeOrder, + _NBit[L[8], L[16]], + _LiteralDType[np.complex128], +): + @property + def name(self) -> L["complex128"]: ... + @property + def str(self) -> L["c16"]: ... + +@final +class CLongDoubleDType( # type: ignore[misc] + _TypeCodes[L["c"], L["G"], L[16]], + _NativeOrder, + _NBit[L[8, 12, 16], L[16, 24, 32]], + _LiteralDType[np.clongdouble], +): + @property + def name(self) -> L["complex128", "complex192", "complex256"]: ... + @property + def str(self) -> L["c16", "c24", "c32"]: ... + +# Python objects: + +@final +class ObjectDType( # type: ignore[misc] + _TypeCodes[L["O"], L["O"], L[17]], + _NoOrder, + _NBit[L[8], L[8]], + _SimpleDType[np.object_], +): + @property + def hasobject(self) -> L[True]: ... + @property + def name(self) -> L["object"]: ... + @property + def str(self) -> L["|O"]: ... + +# Flexible: + +@final +class BytesDType( # type: ignore[misc] + _TypeCodes[L["S"], L["S"], L[18]], + _NoOrder, + _NBit[L[1], _ItemSize_co], + _SimpleDType[np.bytes_], + Generic[_ItemSize_co], +): + def __new__(cls, size: _ItemSize_co, /) -> BytesDType[_ItemSize_co]: ... + @property + def hasobject(self) -> L[False]: ... + @property + def name(self) -> LiteralString: ... + @property + def str(self) -> LiteralString: ... + +@final +class StrDType( # type: ignore[misc] + _TypeCodes[L["U"], L["U"], L[19]], + _NativeOrder, + _NBit[L[4], _ItemSize_co], + _SimpleDType[np.str_], + Generic[_ItemSize_co], +): + def __new__(cls, size: _ItemSize_co, /) -> StrDType[_ItemSize_co]: ... + @property + def hasobject(self) -> L[False]: ... + @property + def name(self) -> LiteralString: ... + @property + def str(self) -> LiteralString: ... + +@final +class VoidDType( # type: ignore[misc] + _TypeCodes[L["V"], L["V"], L[20]], + _NoOrder, + _NBit[L[1], _ItemSize_co], + np.dtype[np.void], # pyright: ignore[reportGeneralTypeIssues] + Generic[_ItemSize_co], +): + # NOTE: `VoidDType(...)` raises a `TypeError` at the moment + def __new__(cls, length: _ItemSize_co, /) -> NoReturn: ... + @property + def base(self) -> Self: ... + @property + def isalignedstruct(self) -> L[False]: ... + @property + def isnative(self) -> L[True]: ... + @property + def ndim(self) -> L[0]: ... + @property + def shape(self) -> tuple[()]: ... + @property + def subdtype(self) -> None: ... + @property + def name(self) -> LiteralString: ... + @property + def str(self) -> LiteralString: ... + +# Other: + +_DateUnit: TypeAlias = L["Y", "M", "W", "D"] +_TimeUnit: TypeAlias = L["h", "m", "s", "ms", "us", "ns", "ps", "fs", "as"] +_DateTimeUnit: TypeAlias = _DateUnit | _TimeUnit + +@final +class DateTime64DType( # type: ignore[misc] + _TypeCodes[L["M"], L["M"], L[21]], + _NativeOrder, + _NBit[L[8], L[8]], + _LiteralDType[np.datetime64], +): + # NOTE: `DateTime64DType(...)` raises a `TypeError` at the moment + # TODO: Once implemented, don't forget the`unit: L["μs"]` overload. + def __new__(cls, unit: _DateTimeUnit, /) -> NoReturn: ... + @property + def name(self) -> L[ + "datetime64", + "datetime64[Y]", + "datetime64[M]", + "datetime64[W]", + "datetime64[D]", + "datetime64[h]", + "datetime64[m]", + "datetime64[s]", + "datetime64[ms]", + "datetime64[us]", + "datetime64[ns]", + "datetime64[ps]", + "datetime64[fs]", + "datetime64[as]", + ]: ... + @property + def str(self) -> L[ + "M8", + "M8[Y]", + "M8[M]", + "M8[W]", + "M8[D]", + "M8[h]", + "M8[m]", + "M8[s]", + "M8[ms]", + "M8[us]", + "M8[ns]", + "M8[ps]", + "M8[fs]", + "M8[as]", + ]: ... + +@final +class TimeDelta64DType( # type: ignore[misc] + _TypeCodes[L["m"], L["m"], L[22]], + _NativeOrder, + _NBit[L[8], L[8]], + _LiteralDType[np.timedelta64], +): + # NOTE: `TimeDelta64DType(...)` raises a `TypeError` at the moment + # TODO: Once implemented, don't forget to overload on `unit: L["μs"]`. + def __new__(cls, unit: _DateTimeUnit, /) -> NoReturn: ... + @property + def name(self) -> L[ + "timedelta64", + "timedelta64[Y]", + "timedelta64[M]", + "timedelta64[W]", + "timedelta64[D]", + "timedelta64[h]", + "timedelta64[m]", + "timedelta64[s]", + "timedelta64[ms]", + "timedelta64[us]", + "timedelta64[ns]", + "timedelta64[ps]", + "timedelta64[fs]", + "timedelta64[as]", + ]: ... + @property + def str(self) -> L[ + "m8", + "m8[Y]", + "m8[M]", + "m8[W]", + "m8[D]", + "m8[h]", + "m8[m]", + "m8[s]", + "m8[ms]", + "m8[us]", + "m8[ns]", + "m8[ps]", + "m8[fs]", + "m8[as]", + ]: ... + +_NaObjectT_co = TypeVar("_NaObjectT_co", default=Never, covariant=True) + +@final +class StringDType( # type: ignore[misc] + _TypeCodes[L["T"], L["T"], L[2056]], + _NativeOrder, + _NBit[L[8], L[16]], + # TODO(jorenham): change once we have a string scalar type: + # https://github.com/numpy/numpy/issues/28165 + np.dtype[str], # type: ignore[type-var] # pyright: ignore[reportGeneralTypeIssues, reportInvalidTypeArguments] + Generic[_NaObjectT_co], +): + @property + def na_object(self) -> _NaObjectT_co: ... + @property + def coerce(self) -> L[True]: ... + + # + @overload + def __new__(cls, /, *, coerce: bool = True) -> Self: ... + @overload + def __new__(cls, /, *, na_object: _NaObjectT_co, coerce: bool = True) -> Self: ... + + # + def __getitem__(self, key: Never, /) -> NoReturn: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + @property + def fields(self) -> None: ... + @property + def base(self) -> Self: ... + @property + def ndim(self) -> L[0]: ... + @property + def shape(self) -> tuple[()]: ... + + # + @property + def name(self) -> L["StringDType64", "StringDType128"]: ... + @property + def subdtype(self) -> None: ... + @property + def type(self) -> type[str]: ... + @property + def str(self) -> L["|T8", "|T16"]: ... + + # + @property + def hasobject(self) -> L[True]: ... + @property + def isalignedstruct(self) -> L[False]: ... + @property + def isnative(self) -> L[True]: ... diff --git a/.venv/lib/python3.12/site-packages/numpy/exceptions.pyi b/.venv/lib/python3.12/site-packages/numpy/exceptions.pyi new file mode 100644 index 0000000000000000000000000000000000000000..9bcc097dfc0f8b08fa6f16e483be8e123e52b776 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/exceptions.pyi @@ -0,0 +1,27 @@ +from typing import overload + +__all__ = [ + "ComplexWarning", + "VisibleDeprecationWarning", + "ModuleDeprecationWarning", + "TooHardError", + "AxisError", + "DTypePromotionError", +] + +class ComplexWarning(RuntimeWarning): ... +class ModuleDeprecationWarning(DeprecationWarning): ... +class VisibleDeprecationWarning(UserWarning): ... +class RankWarning(RuntimeWarning): ... +class TooHardError(RuntimeError): ... +class DTypePromotionError(TypeError): ... + +class AxisError(ValueError, IndexError): + __slots__ = "_msg", "axis", "ndim" + + axis: int | None + ndim: int | None + @overload + def __init__(self, axis: str, ndim: None = ..., msg_prefix: None = ...) -> None: ... + @overload + def __init__(self, axis: int, ndim: int, msg_prefix: str | None = ...) -> None: ... diff --git a/.venv/lib/python3.12/site-packages/numpy/matlib.pyi b/.venv/lib/python3.12/site-packages/numpy/matlib.pyi new file mode 100644 index 0000000000000000000000000000000000000000..baeadc078028ebf79e2a2bf8c25216f84fddf0fc --- /dev/null +++ b/.venv/lib/python3.12/site-packages/numpy/matlib.pyi @@ -0,0 +1,582 @@ +from typing import Any, Literal, TypeAlias, TypeVar, overload + +import numpy as np +import numpy.typing as npt +from numpy import ( # noqa: F401 + False_, + ScalarType, + True_, + __array_namespace_info__, + __version__, + abs, + absolute, + acos, + acosh, + add, + all, + allclose, + amax, + amin, + angle, + any, + append, + apply_along_axis, + apply_over_axes, + arange, + arccos, + arccosh, + arcsin, + arcsinh, + arctan, + arctan2, + arctanh, + argmax, + argmin, + argpartition, + argsort, + argwhere, + around, + array, + array2string, + array_equal, + array_equiv, + array_repr, + array_split, + array_str, + asanyarray, + asarray, + asarray_chkfinite, + ascontiguousarray, + asfortranarray, + asin, + asinh, + asmatrix, + astype, + atan, + atan2, + atanh, + atleast_1d, + atleast_2d, + atleast_3d, + average, + bartlett, + base_repr, + binary_repr, + bincount, + bitwise_and, + bitwise_count, + bitwise_invert, + bitwise_left_shift, + bitwise_not, + bitwise_or, + bitwise_right_shift, + bitwise_xor, + blackman, + block, + bmat, + bool, + bool_, + broadcast, + broadcast_arrays, + broadcast_shapes, + broadcast_to, + busday_count, + busday_offset, + busdaycalendar, + byte, + bytes_, + c_, + can_cast, + cbrt, + cdouble, + ceil, + char, + character, + choose, + clip, + clongdouble, + column_stack, + common_type, + complex64, + complex128, + complex256, + complexfloating, + compress, + concat, + concatenate, + conj, + conjugate, + convolve, + copy, + copysign, + copyto, + core, + corrcoef, + correlate, + cos, + cosh, + count_nonzero, + cov, + cross, + csingle, + ctypeslib, + cumprod, + cumsum, + cumulative_prod, + cumulative_sum, + datetime64, + datetime_as_string, + datetime_data, + deg2rad, + degrees, + delete, + diag, + diag_indices, + diag_indices_from, + diagflat, + diagonal, + diff, + digitize, + divide, + divmod, + dot, + double, + dsplit, + dstack, + dtype, + dtypes, + e, + ediff1d, + einsum, + einsum_path, + emath, + empty_like, + equal, + errstate, + euler_gamma, + exceptions, + exp, + exp2, + expand_dims, + expm1, + extract, + f2py, + fabs, + fft, + fill_diagonal, + finfo, + fix, + flatiter, + flatnonzero, + flexible, + flip, + fliplr, + flipud, + float16, + float32, + float64, + float128, + float_power, + floating, + floor, + floor_divide, + fmax, + fmin, + fmod, + format_float_positional, + format_float_scientific, + frexp, + from_dlpack, + frombuffer, + fromfile, + fromfunction, + fromiter, + frompyfunc, + fromregex, + fromstring, + full, + full_like, + gcd, + generic, + genfromtxt, + geomspace, + get_include, + get_printoptions, + getbufsize, + geterr, + geterrcall, + gradient, + greater, + greater_equal, + half, + hamming, + hanning, + heaviside, + histogram, + histogram2d, + histogram_bin_edges, + histogramdd, + hsplit, + hstack, + hypot, + i0, + iinfo, + imag, + in1d, + index_exp, + indices, + inexact, + inf, + info, + inner, + insert, + int8, + int16, + int32, + int64, + int_, + intc, + integer, + interp, + intersect1d, + intp, + invert, + is_busday, + isclose, + iscomplex, + iscomplexobj, + isdtype, + isfinite, + isfortran, + isin, + isinf, + isnan, + isnat, + isneginf, + isposinf, + isreal, + isrealobj, + isscalar, + issubdtype, + iterable, + ix_, + kaiser, + kron, + lcm, + ldexp, + left_shift, + less, + less_equal, + lexsort, + lib, + linalg, + linspace, + little_endian, + load, + loadtxt, + log, + log1p, + log2, + log10, + logaddexp, + logaddexp2, + logical_and, + logical_not, + logical_or, + logical_xor, + logspace, + long, + longdouble, + longlong, + ma, + mask_indices, + matmul, + matrix, + matrix_transpose, + matvec, + max, + maximum, + may_share_memory, + mean, + median, + memmap, + meshgrid, + mgrid, + min, + min_scalar_type, + minimum, + mintypecode, + mod, + modf, + moveaxis, + multiply, + nan, + nan_to_num, + nanargmax, + nanargmin, + nancumprod, + nancumsum, + nanmax, + nanmean, + nanmedian, + nanmin, + nanpercentile, + nanprod, + nanquantile, + nanstd, + nansum, + nanvar, + ndarray, + ndenumerate, + ndim, + ndindex, + nditer, + negative, + nested_iters, + newaxis, + nextafter, + nonzero, + not_equal, + number, + object_, + ogrid, + ones_like, + outer, + packbits, + pad, + partition, + percentile, + permute_dims, + pi, + piecewise, + place, + poly, + poly1d, + polyadd, + polyder, + polydiv, + polyfit, + polyint, + polymul, + polynomial, + polysub, + polyval, + positive, + pow, + power, + printoptions, + prod, + promote_types, + ptp, + put, + put_along_axis, + putmask, + quantile, + r_, + rad2deg, + radians, + random, + ravel, + ravel_multi_index, + real, + real_if_close, + rec, + recarray, + reciprocal, + record, + remainder, + repeat, + require, + reshape, + resize, + result_type, + right_shift, + rint, + roll, + rollaxis, + roots, + rot90, + round, + row_stack, + s_, + save, + savetxt, + savez, + savez_compressed, + sctypeDict, + searchsorted, + select, + set_printoptions, + setbufsize, + setdiff1d, + seterr, + seterrcall, + setxor1d, + shape, + shares_memory, + short, + show_config, + show_runtime, + sign, + signbit, + signedinteger, + sin, + sinc, + single, + sinh, + size, + sort, + sort_complex, + spacing, + split, + sqrt, + square, + squeeze, + stack, + std, + str_, + strings, + subtract, + sum, + swapaxes, + take, + take_along_axis, + tan, + tanh, + tensordot, + test, + testing, + tile, + timedelta64, + trace, + transpose, + trapezoid, + trapz, + tri, + tril, + tril_indices, + tril_indices_from, + trim_zeros, + triu, + triu_indices, + triu_indices_from, + true_divide, + trunc, + typecodes, + typename, + typing, + ubyte, + ufunc, + uint, + uint8, + uint16, + uint32, + uint64, + uintc, + uintp, + ulong, + ulonglong, + union1d, + unique, + unique_all, + unique_counts, + unique_inverse, + unique_values, + unpackbits, + unravel_index, + unsignedinteger, + unstack, + unwrap, + ushort, + vander, + var, + vdot, + vecdot, + vecmat, + vectorize, + void, + vsplit, + vstack, + where, + zeros_like, +) +from numpy._typing import _ArrayLike, _DTypeLike + +__all__ = ["rand", "randn", "repmat"] +__all__ += np.__all__ + +### + +_T = TypeVar("_T", bound=np.generic) +_Matrix: TypeAlias = np.matrix[tuple[int, int], np.dtype[_T]] +_Order: TypeAlias = Literal["C", "F"] + +### + +# +@overload +def empty(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ... +@overload +def empty(shape: int | tuple[int, int], dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ... +@overload +def empty(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ... + +# +@overload +def ones(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ... +@overload +def ones(shape: int | tuple[int, int], dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ... +@overload +def ones(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ... + +# +@overload +def zeros(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ... +@overload +def zeros(shape: int | tuple[int, int], dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ... +@overload +def zeros(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ... + +# +@overload +def identity(n: int, dtype: None = None) -> _Matrix[np.float64]: ... +@overload +def identity(n: int, dtype: _DTypeLike[_T]) -> _Matrix[_T]: ... +@overload +def identity(n: int, dtype: npt.DTypeLike | None = None) -> _Matrix[Any]: ... + +# +@overload +def eye( + n: int, + M: int | None = None, + k: int = 0, + dtype: type[np.float64] | None = ..., + order: _Order = "C", +) -> _Matrix[np.float64]: ... +@overload +def eye(n: int, M: int | None, k: int, dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ... +@overload +def eye(n: int, M: int | None = None, k: int = 0, *, dtype: _DTypeLike[_T], order: _Order = "C") -> _Matrix[_T]: ... +@overload +def eye(n: int, M: int | None = None, k: int = 0, dtype: npt.DTypeLike = ..., order: _Order = "C") -> _Matrix[Any]: ... + +# +@overload +def rand(arg: int | tuple[()] | tuple[int] | tuple[int, int], /) -> _Matrix[np.float64]: ... +@overload +def rand(arg: int, /, *args: int) -> _Matrix[np.float64]: ... + +# +@overload +def randn(arg: int | tuple[()] | tuple[int] | tuple[int, int], /) -> _Matrix[np.float64]: ... +@overload +def randn(arg: int, /, *args: int) -> _Matrix[np.float64]: ... + +# +@overload +def repmat(a: _Matrix[_T], m: int, n: int) -> _Matrix[_T]: ... +@overload +def repmat(a: _ArrayLike[_T], m: int, n: int) -> npt.NDArray[_T]: ... +@overload +def repmat(a: npt.ArrayLike, m: int, n: int) -> npt.NDArray[Any]: ... diff --git a/.venv/lib/python3.12/site-packages/numpy/py.typed b/.venv/lib/python3.12/site-packages/numpy/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/METADATA b/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..cb533db38cb400ef0b0e71cea45e7ce506422bfd --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/METADATA @@ -0,0 +1,44 @@ +Metadata-Version: 2.2 +Name: nvidia-cublas-cu12 +Version: 12.8.4.1 +Summary: CUBLAS native runtime libraries +Home-page: https://developer.nvidia.com/cuda-zone +Author: Nvidia CUDA Installer Team +Author-email: compute_installer@nvidia.com +License: NVIDIA Proprietary Software +Keywords: cuda,nvidia,runtime,machine learning,deep learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: Other/Proprietary License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Requires-Python: >=3 +License-File: License.txt +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: home-page +Dynamic: keywords +Dynamic: license +Dynamic: requires-python +Dynamic: summary + +CUBLAS native runtime libraries diff --git a/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/RECORD b/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..d794952a3781dd8c9ca175c04b28d6286811e807 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/RECORD @@ -0,0 +1,23 @@ +nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/__pycache__/__init__.cpython-312.pyc,, +nvidia/cublas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/cublas/__pycache__/__init__.cpython-312.pyc,, +nvidia/cublas/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/cublas/include/__pycache__/__init__.cpython-312.pyc,, +nvidia/cublas/include/cublas.h,sha256=a0lLqy-k47NuwyDjuueC3W0Mpc908MTU7o5sMJqE-1w,41246 +nvidia/cublas/include/cublasLt.h,sha256=oH9TR01H5CWfGPIjJk6-Ljg8eQOu0gho7TNt83gCmwg,102451 +nvidia/cublas/include/cublasXt.h,sha256=CW9dyXYGSUW1wEXrVVyhU6OxBK1PUvMoYdVGlQT7L9A,37380 +nvidia/cublas/include/cublas_api.h,sha256=A4Jvv9elvoJIDw8ReUP7qBnSxEvdslc-ghW_ycq_qAU,374363 +nvidia/cublas/include/cublas_v2.h,sha256=qxMdB5jb97luEfw61LEAB-Wlr8A9DLBvO4rRypDCNKw,15460 +nvidia/cublas/include/nvblas.h,sha256=dXCLR-2oUiJFzLsDtIAK09m42ct4G0HWdYzBUuDPXpc,23341 +nvidia/cublas/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +nvidia/cublas/lib/__pycache__/__init__.cpython-312.pyc,, +nvidia/cublas/lib/libcublas.so.12,sha256=Axzmwsv7uUaPBAUnyrXFmQac5WCec-KPh1A4gQY-rCE,116388640 +nvidia/cublas/lib/libcublasLt.so.12,sha256=ELXmYxz4EVxmHriV7RUzgmMItY95VkZvU9I2pAybYiw,751771728 +nvidia/cublas/lib/libnvblas.so.12,sha256=nSRIINMpZvCvR6_mye5vNLIw-v6H6gFB3HEkGl0rNAw,753824 +nvidia_cublas_cu12-12.8.4.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +nvidia_cublas_cu12-12.8.4.1.dist-info/License.txt,sha256=rW9YU_ugyg0VnQ9Y1JrkmDDC-Mk_epJki5zpCttMbM0,59262 +nvidia_cublas_cu12-12.8.4.1.dist-info/METADATA,sha256=MQVW8cLDHsUX1LBJ6vEjdAgdHFLI702Ozqsqrx7f8t8,1683 +nvidia_cublas_cu12-12.8.4.1.dist-info/RECORD,, +nvidia_cublas_cu12-12.8.4.1.dist-info/WHEEL,sha256=wwQXGCXJQEUF59fKjBnVVzOkzi78E6rE_-QuUR4ZT4w,109 +nvidia_cublas_cu12-12.8.4.1.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7 diff --git a/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..6a0d9dc1b21a540a280fda3e78767d22a3b7ed6e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cublas_cu12-12.8.4.1.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.8.1) +Root-Is-Purelib: true +Tag: py3-none-manylinux_2_27_x86_64 + diff --git a/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..287a9d7e1a3d4435e9542cc8216b8c5eaf2c0ed2 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.8.0) +Root-Is-Purelib: true +Tag: py3-none-manylinux2014_x86_64 +Tag: py3-none-manylinux_2_17_x86_64 + diff --git a/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cuda_cupti_cu12-12.8.90.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/.venv/lib/python3.12/site-packages/nvidia_cuda_nvrtc_cu12-12.8.93.dist-info/METADATA b/.venv/lib/python3.12/site-packages/nvidia_cuda_nvrtc_cu12-12.8.93.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..f8e857fa2ae30c6714fae1abaa2f8196efda7ab9 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cuda_nvrtc_cu12-12.8.93.dist-info/METADATA @@ -0,0 +1,44 @@ +Metadata-Version: 2.2 +Name: nvidia-cuda-nvrtc-cu12 +Version: 12.8.93 +Summary: NVRTC native runtime libraries +Home-page: https://developer.nvidia.com/cuda-zone +Author: Nvidia CUDA Installer Team +Author-email: compute_installer@nvidia.com +License: NVIDIA Proprietary Software +Keywords: cuda,nvidia,runtime,machine learning,deep learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: Other/Proprietary License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Requires-Python: >=3 +License-File: License.txt +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: home-page +Dynamic: keywords +Dynamic: license +Dynamic: requires-python +Dynamic: summary + +NVRTC native runtime libraries diff --git a/.venv/lib/python3.12/site-packages/nvidia_cuda_nvrtc_cu12-12.8.93.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/nvidia_cuda_nvrtc_cu12-12.8.93.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cuda_nvrtc_cu12-12.8.93.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/.venv/lib/python3.12/site-packages/nvidia_cuda_runtime_cu12-12.8.90.dist-info/License.txt b/.venv/lib/python3.12/site-packages/nvidia_cuda_runtime_cu12-12.8.90.dist-info/License.txt new file mode 100644 index 0000000000000000000000000000000000000000..b491c70e0aef319022ded661e111ddbd45b8a17f --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cuda_runtime_cu12-12.8.90.dist-info/License.txt @@ -0,0 +1,1568 @@ +End User License Agreement +-------------------------- + + +Preface +------- + +The Software License Agreement in Chapter 1 and the Supplement +in Chapter 2 contain license terms and conditions that govern +the use of NVIDIA software. By accepting this agreement, you +agree to comply with all the terms and conditions applicable +to the product(s) included herein. + + +NVIDIA Driver + + +Description + +This package contains the operating system driver and +fundamental system software components for NVIDIA GPUs. + + +NVIDIA CUDA Toolkit + + +Description + +The NVIDIA CUDA Toolkit provides command-line and graphical +tools for building, debugging and optimizing the performance +of applications accelerated by NVIDIA GPUs, runtime and math +libraries, and documentation including programming guides, +user manuals, and API references. + + +Default Install Location of CUDA Toolkit + +Windows platform: + +%ProgramFiles%\NVIDIA GPU Computing Toolkit\CUDA\v#.# + +Linux platform: + +/usr/local/cuda-#.# + +Mac platform: + +/Developer/NVIDIA/CUDA-#.# + + +NVIDIA CUDA Samples + + +Description + +This package includes over 100+ CUDA examples that demonstrate +various CUDA programming principles, and efficient CUDA +implementation of algorithms in specific application domains. + + +Default Install Location of CUDA Samples + +Windows platform: + +%ProgramData%\NVIDIA Corporation\CUDA Samples\v#.# + +Linux platform: + +/usr/local/cuda-#.#/samples + +and + +$HOME/NVIDIA_CUDA-#.#_Samples + +Mac platform: + +/Developer/NVIDIA/CUDA-#.#/samples + + +NVIDIA Nsight Visual Studio Edition (Windows only) + + +Description + +NVIDIA Nsight Development Platform, Visual Studio Edition is a +development environment integrated into Microsoft Visual +Studio that provides tools for debugging, profiling, analyzing +and optimizing your GPU computing and graphics applications. + + +Default Install Location of Nsight Visual Studio Edition + +Windows platform: + +%ProgramFiles(x86)%\NVIDIA Corporation\Nsight Visual Studio Edition #.# + + +1. License Agreement for NVIDIA Software Development Kits +--------------------------------------------------------- + + +Release Date: July 26, 2018 +--------------------------- + + +Important NoticeRead before downloading, installing, +copying or using the licensed software: +------------------------------------------------------- + +This license agreement, including exhibits attached +("Agreement”) is a legal agreement between you and NVIDIA +Corporation ("NVIDIA") and governs your use of a NVIDIA +software development kit (“SDK”). + +Each SDK has its own set of software and materials, but here +is a description of the types of items that may be included in +a SDK: source code, header files, APIs, data sets and assets +(examples include images, textures, models, scenes, videos, +native API input/output files), binary software, sample code, +libraries, utility programs, programming code and +documentation. + +This Agreement can be accepted only by an adult of legal age +of majority in the country in which the SDK is used. + +If you are entering into this Agreement on behalf of a company +or other legal entity, you represent that you have the legal +authority to bind the entity to this Agreement, in which case +“you” will mean the entity you represent. + +If you don’t have the required age or authority to accept +this Agreement, or if you don’t accept all the terms and +conditions of this Agreement, do not download, install or use +the SDK. + +You agree to use the SDK only for purposes that are permitted +by (a) this Agreement, and (b) any applicable law, regulation +or generally accepted practices or guidelines in the relevant +jurisdictions. + + +1.1. License + + +1.1.1. License Grant + +Subject to the terms of this Agreement, NVIDIA hereby grants +you a non-exclusive, non-transferable license, without the +right to sublicense (except as expressly provided in this +Agreement) to: + + 1. Install and use the SDK, + + 2. Modify and create derivative works of sample source code + delivered in the SDK, and + + 3. Distribute those portions of the SDK that are identified + in this Agreement as distributable, as incorporated in + object code format into a software application that meets + the distribution requirements indicated in this Agreement. + + +1.1.2. Distribution Requirements + +These are the distribution requirements for you to exercise +the distribution grant: + + 1. Your application must have material additional + functionality, beyond the included portions of the SDK. + + 2. The distributable portions of the SDK shall only be + accessed by your application. + + 3. The following notice shall be included in modifications + and derivative works of sample source code distributed: + “This software contains source code provided by NVIDIA + Corporation.” + + 4. Unless a developer tool is identified in this Agreement + as distributable, it is delivered for your internal use + only. + + 5. The terms under which you distribute your application + must be consistent with the terms of this Agreement, + including (without limitation) terms relating to the + license grant and license restrictions and protection of + NVIDIA’s intellectual property rights. Additionally, you + agree that you will protect the privacy, security and + legal rights of your application users. + + 6. You agree to notify NVIDIA in writing of any known or + suspected distribution or use of the SDK not in compliance + with the requirements of this Agreement, and to enforce + the terms of your agreements with respect to distributed + SDK. + + +1.1.3. Authorized Users + +You may allow employees and contractors of your entity or of +your subsidiary(ies) to access and use the SDK from your +secure network to perform work on your behalf. + +If you are an academic institution you may allow users +enrolled or employed by the academic institution to access and +use the SDK from your secure network. + +You are responsible for the compliance with the terms of this +Agreement by your authorized users. If you become aware that +your authorized users didn’t follow the terms of this +Agreement, you agree to take reasonable steps to resolve the +non-compliance and prevent new occurrences. + + +1.1.4. Pre-Release SDK + +The SDK versions identified as alpha, beta, preview or +otherwise as pre-release, may not be fully functional, may +contain errors or design flaws, and may have reduced or +different security, privacy, accessibility, availability, and +reliability standards relative to commercial versions of +NVIDIA software and materials. Use of a pre-release SDK may +result in unexpected results, loss of data, project delays or +other unpredictable damage or loss. + +You may use a pre-release SDK at your own risk, understanding +that pre-release SDKs are not intended for use in production +or business-critical systems. + +NVIDIA may choose not to make available a commercial version +of any pre-release SDK. NVIDIA may also choose to abandon +development and terminate the availability of a pre-release +SDK at any time without liability. + + +1.1.5. Updates + +NVIDIA may, at its option, make available patches, workarounds +or other updates to this SDK. Unless the updates are provided +with their separate governing terms, they are deemed part of +the SDK licensed to you as provided in this Agreement. You +agree that the form and content of the SDK that NVIDIA +provides may change without prior notice to you. While NVIDIA +generally maintains compatibility between versions, NVIDIA may +in some cases make changes that introduce incompatibilities in +future versions of the SDK. + + +1.1.6. Third Party Licenses + +The SDK may come bundled with, or otherwise include or be +distributed with, third party software licensed by a NVIDIA +supplier and/or open source software provided under an open +source license. Use of third party software is subject to the +third-party license terms, or in the absence of third party +terms, the terms of this Agreement. Copyright to third party +software is held by the copyright holders indicated in the +third-party software or license. + + +1.1.7. Reservation of Rights + +NVIDIA reserves all rights, title, and interest in and to the +SDK, not expressly granted to you under this Agreement. + + +1.2. Limitations + +The following license limitations apply to your use of the +SDK: + + 1. You may not reverse engineer, decompile or disassemble, + or remove copyright or other proprietary notices from any + portion of the SDK or copies of the SDK. + + 2. Except as expressly provided in this Agreement, you may + not copy, sell, rent, sublicense, transfer, distribute, + modify, or create derivative works of any portion of the + SDK. For clarity, you may not distribute or sublicense the + SDK as a stand-alone product. + + 3. Unless you have an agreement with NVIDIA for this + purpose, you may not indicate that an application created + with the SDK is sponsored or endorsed by NVIDIA. + + 4. You may not bypass, disable, or circumvent any + encryption, security, digital rights management or + authentication mechanism in the SDK. + + 5. You may not use the SDK in any manner that would cause it + to become subject to an open source software license. As + examples, licenses that require as a condition of use, + modification, and/or distribution that the SDK be: + + a. Disclosed or distributed in source code form; + + b. Licensed for the purpose of making derivative works; + or + + c. Redistributable at no charge. + + 6. Unless you have an agreement with NVIDIA for this + purpose, you may not use the SDK with any system or + application where the use or failure of the system or + application can reasonably be expected to threaten or + result in personal injury, death, or catastrophic loss. + Examples include use in avionics, navigation, military, + medical, life support or other life critical applications. + NVIDIA does not design, test or manufacture the SDK for + these critical uses and NVIDIA shall not be liable to you + or any third party, in whole or in part, for any claims or + damages arising from such uses. + + 7. You agree to defend, indemnify and hold harmless NVIDIA + and its affiliates, and their respective employees, + contractors, agents, officers and directors, from and + against any and all claims, damages, obligations, losses, + liabilities, costs or debt, fines, restitutions and + expenses (including but not limited to attorney’s fees + and costs incident to establishing the right of + indemnification) arising out of or related to your use of + the SDK outside of the scope of this Agreement, or not in + compliance with its terms. + + +1.3. Ownership + + 1. NVIDIA or its licensors hold all rights, title and + interest in and to the SDK and its modifications and + derivative works, including their respective intellectual + property rights, subject to your rights described in this + section. This SDK may include software and materials from + NVIDIA’s licensors, and these licensors are intended + third party beneficiaries that may enforce this Agreement + with respect to their intellectual property rights. + + 2. You hold all rights, title and interest in and to your + applications and your derivative works of the sample + source code delivered in the SDK, including their + respective intellectual property rights, subject to + NVIDIA’s rights described in this section. + + 3. You may, but don’t have to, provide to NVIDIA + suggestions, feature requests or other feedback regarding + the SDK, including possible enhancements or modifications + to the SDK. For any feedback that you voluntarily provide, + you hereby grant NVIDIA and its affiliates a perpetual, + non-exclusive, worldwide, irrevocable license to use, + reproduce, modify, license, sublicense (through multiple + tiers of sublicensees), and distribute (through multiple + tiers of distributors) it without the payment of any + royalties or fees to you. NVIDIA will use feedback at its + choice. NVIDIA is constantly looking for ways to improve + its products, so you may send feedback to NVIDIA through + the developer portal at https://developer.nvidia.com. + + +1.4. No Warranties + +THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL +FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND +ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND +OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, +BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE +ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO +WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF +DEALING OR COURSE OF TRADE. + + +1.5. Limitation of Liability + +TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS +AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL, +PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS +OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF +PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION +WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK, +WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH +OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE), +PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF +LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES +TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS +AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE +NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS +LIMIT. + +These exclusions and limitations of liability shall apply +regardless if NVIDIA or its affiliates have been advised of +the possibility of such damages, and regardless of whether a +remedy fails its essential purpose. These exclusions and +limitations of liability form an essential basis of the +bargain between the parties, and, absent any of these +exclusions or limitations of liability, the provisions of this +Agreement, including, without limitation, the economic terms, +would be substantially different. + + +1.6. Termination + + 1. This Agreement will continue to apply until terminated by + either you or NVIDIA as described below. + + 2. If you want to terminate this Agreement, you may do so by + stopping to use the SDK. + + 3. NVIDIA may, at any time, terminate this Agreement if: + + a. (i) you fail to comply with any term of this + Agreement and the non-compliance is not fixed within + thirty (30) days following notice from NVIDIA (or + immediately if you violate NVIDIA’s intellectual + property rights); + + b. (ii) you commence or participate in any legal + proceeding against NVIDIA with respect to the SDK; or + + c. (iii) NVIDIA decides to no longer provide the SDK in + a country or, in NVIDIA’s sole discretion, the + continued use of it is no longer commercially viable. + + 4. Upon any termination of this Agreement, you agree to + promptly discontinue use of the SDK and destroy all copies + in your possession or control. Your prior distributions in + accordance with this Agreement are not affected by the + termination of this Agreement. Upon written request, you + will certify in writing that you have complied with your + commitments under this section. Upon any termination of + this Agreement all provisions survive except for the + license grant provisions. + + +1.7. General + +If you wish to assign this Agreement or your rights and +obligations, including by merger, consolidation, dissolution +or operation of law, contact NVIDIA to ask for permission. Any +attempted assignment not approved by NVIDIA in writing shall +be void and of no effect. NVIDIA may assign, delegate or +transfer this Agreement and its rights and obligations, and if +to a non-affiliate you will be notified. + +You agree to cooperate with NVIDIA and provide reasonably +requested information to verify your compliance with this +Agreement. + +This Agreement will be governed in all respects by the laws of +the United States and of the State of Delaware as those laws +are applied to contracts entered into and performed entirely +within Delaware by Delaware residents, without regard to the +conflicts of laws principles. The United Nations Convention on +Contracts for the International Sale of Goods is specifically +disclaimed. You agree to all terms of this Agreement in the +English language. + +The state or federal courts residing in Santa Clara County, +California shall have exclusive jurisdiction over any dispute +or claim arising out of this Agreement. Notwithstanding this, +you agree that NVIDIA shall still be allowed to apply for +injunctive remedies or an equivalent type of urgent legal +relief in any jurisdiction. + +If any court of competent jurisdiction determines that any +provision of this Agreement is illegal, invalid or +unenforceable, such provision will be construed as limited to +the extent necessary to be consistent with and fully +enforceable under the law and the remaining provisions will +remain in full force and effect. Unless otherwise specified, +remedies are cumulative. + +Each party acknowledges and agrees that the other is an +independent contractor in the performance of this Agreement. + +The SDK has been developed entirely at private expense and is +“commercial items” consisting of “commercial computer +software” and “commercial computer software +documentation” provided with RESTRICTED RIGHTS. Use, +duplication or disclosure by the U.S. Government or a U.S. +Government subcontractor is subject to the restrictions in +this Agreement pursuant to DFARS 227.7202-3(a) or as set forth +in subparagraphs (c)(1) and (2) of the Commercial Computer +Software - Restricted Rights clause at FAR 52.227-19, as +applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas +Expressway, Santa Clara, CA 95051. + +The SDK is subject to United States export laws and +regulations. You agree that you will not ship, transfer or +export the SDK into any country, or use the SDK in any manner, +prohibited by the United States Bureau of Industry and +Security or economic sanctions regulations administered by the +U.S. Department of Treasury’s Office of Foreign Assets +Control (OFAC), or any applicable export laws, restrictions or +regulations. These laws include restrictions on destinations, +end users and end use. By accepting this Agreement, you +confirm that you are not a resident or citizen of any country +currently embargoed by the U.S. and that you are not otherwise +prohibited from receiving the SDK. + +Any notice delivered by NVIDIA to you under this Agreement +will be delivered via mail, email or fax. You agree that any +notices that NVIDIA sends you electronically will satisfy any +legal communication requirements. Please direct your legal +notices or other correspondence to NVIDIA Corporation, 2788 +San Tomas Expressway, Santa Clara, California 95051, United +States of America, Attention: Legal Department. + +This Agreement and any exhibits incorporated into this +Agreement constitute the entire agreement of the parties with +respect to the subject matter of this Agreement and supersede +all prior negotiations or documentation exchanged between the +parties relating to this SDK license. Any additional and/or +conflicting terms on documents issued by you are null, void, +and invalid. Any amendment or waiver under this Agreement +shall be in writing and signed by representatives of both +parties. + + +2. CUDA Toolkit Supplement to Software License Agreement for +NVIDIA Software Development Kits +------------------------------------------------------------ + + +Release date: August 16, 2018 +----------------------------- + +The terms in this supplement govern your use of the NVIDIA +CUDA Toolkit SDK under the terms of your license agreement +(“Agreement”) as modified by this supplement. Capitalized +terms used but not defined below have the meaning assigned to +them in the Agreement. + +This supplement is an exhibit to the Agreement and is +incorporated as an integral part of the Agreement. In the +event of conflict between the terms in this supplement and the +terms in the Agreement, the terms in this supplement govern. + + +2.1. License Scope + +The SDK is licensed for you to develop applications only for +use in systems with NVIDIA GPUs. + + +2.2. Distribution + +The portions of the SDK that are distributable under the +Agreement are listed in Attachment A. + + +2.3. Operating Systems + +Those portions of the SDK designed exclusively for use on the +Linux or FreeBSD operating systems, or other operating systems +derived from the source code to these operating systems, may +be copied and redistributed for use in accordance with this +Agreement, provided that the object code files are not +modified in any way (except for unzipping of compressed +files). + + +2.4. Audio and Video Encoders and Decoders + +You acknowledge and agree that it is your sole responsibility +to obtain any additional third-party licenses required to +make, have made, use, have used, sell, import, and offer for +sale your products or services that include or incorporate any +third-party software and content relating to audio and/or +video encoders and decoders from, including but not limited +to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A., +MPEG-LA, and Coding Technologies. NVIDIA does not grant to you +under this Agreement any necessary patent or other rights with +respect to any audio and/or video encoders and decoders. + + +2.5. Licensing + +If the distribution terms in this Agreement are not suitable +for your organization, or for any questions regarding this +Agreement, please contact NVIDIA at +nvidia-compute-license-questions@nvidia.com. + + +2.6. Attachment A + +The following portions of the SDK are distributable under the +Agreement: + +Component + +CUDA Runtime + +Windows + +cudart.dll, cudart_static.lib, cudadevrt.lib + +Mac OSX + +libcudart.dylib, libcudart_static.a, libcudadevrt.a + +Linux + +libcudart.so, libcudart_static.a, libcudadevrt.a + +Android + +libcudart.so, libcudart_static.a, libcudadevrt.a + +Component + +CUDA FFT Library + +Windows + +cufft.dll, cufftw.dll, cufft.lib, cufftw.lib + +Mac OSX + +libcufft.dylib, libcufft_static.a, libcufftw.dylib, +libcufftw_static.a + +Linux + +libcufft.so, libcufft_static.a, libcufftw.so, +libcufftw_static.a + +Android + +libcufft.so, libcufft_static.a, libcufftw.so, +libcufftw_static.a + +Component + +CUDA BLAS Library + +Windows + +cublas.dll, cublasLt.dll + +Mac OSX + +libcublas.dylib, libcublasLt.dylib, libcublas_static.a, +libcublasLt_static.a + +Linux + +libcublas.so, libcublasLt.so, libcublas_static.a, +libcublasLt_static.a + +Android + +libcublas.so, libcublasLt.so, libcublas_static.a, +libcublasLt_static.a + +Component + +NVIDIA "Drop-in" BLAS Library + +Windows + +nvblas.dll + +Mac OSX + +libnvblas.dylib + +Linux + +libnvblas.so + +Component + +CUDA Sparse Matrix Library + +Windows + +cusparse.dll, cusparse.lib + +Mac OSX + +libcusparse.dylib, libcusparse_static.a + +Linux + +libcusparse.so, libcusparse_static.a + +Android + +libcusparse.so, libcusparse_static.a + +Component + +CUDA Linear Solver Library + +Windows + +cusolver.dll, cusolver.lib + +Mac OSX + +libcusolver.dylib, libcusolver_static.a + +Linux + +libcusolver.so, libcusolver_static.a + +Android + +libcusolver.so, libcusolver_static.a + +Component + +CUDA Random Number Generation Library + +Windows + +curand.dll, curand.lib + +Mac OSX + +libcurand.dylib, libcurand_static.a + +Linux + +libcurand.so, libcurand_static.a + +Android + +libcurand.so, libcurand_static.a + +Component + +CUDA Accelerated Graph Library + +Component + +NVIDIA Performance Primitives Library + +Windows + +nppc.dll, nppc.lib, nppial.dll, nppial.lib, nppicc.dll, +nppicc.lib, nppicom.dll, nppicom.lib, nppidei.dll, +nppidei.lib, nppif.dll, nppif.lib, nppig.dll, nppig.lib, +nppim.dll, nppim.lib, nppist.dll, nppist.lib, nppisu.dll, +nppisu.lib, nppitc.dll, nppitc.lib, npps.dll, npps.lib + +Mac OSX + +libnppc.dylib, libnppc_static.a, libnppial.dylib, +libnppial_static.a, libnppicc.dylib, libnppicc_static.a, +libnppicom.dylib, libnppicom_static.a, libnppidei.dylib, +libnppidei_static.a, libnppif.dylib, libnppif_static.a, +libnppig.dylib, libnppig_static.a, libnppim.dylib, +libnppisu_static.a, libnppitc.dylib, libnppitc_static.a, +libnpps.dylib, libnpps_static.a + +Linux + +libnppc.so, libnppc_static.a, libnppial.so, +libnppial_static.a, libnppicc.so, libnppicc_static.a, +libnppicom.so, libnppicom_static.a, libnppidei.so, +libnppidei_static.a, libnppif.so, libnppif_static.a +libnppig.so, libnppig_static.a, libnppim.so, +libnppim_static.a, libnppist.so, libnppist_static.a, +libnppisu.so, libnppisu_static.a, libnppitc.so +libnppitc_static.a, libnpps.so, libnpps_static.a + +Android + +libnppc.so, libnppc_static.a, libnppial.so, +libnppial_static.a, libnppicc.so, libnppicc_static.a, +libnppicom.so, libnppicom_static.a, libnppidei.so, +libnppidei_static.a, libnppif.so, libnppif_static.a +libnppig.so, libnppig_static.a, libnppim.so, +libnppim_static.a, libnppist.so, libnppist_static.a, +libnppisu.so, libnppisu_static.a, libnppitc.so +libnppitc_static.a, libnpps.so, libnpps_static.a + +Component + +NVIDIA JPEG Library + +Linux + +libnvjpeg.so, libnvjpeg_static.a + +Component + +Internal common library required for statically linking to +cuBLAS, cuSPARSE, cuFFT, cuRAND, nvJPEG and NPP + +Mac OSX + +libculibos.a + +Linux + +libculibos.a + +Component + +NVIDIA Runtime Compilation Library and Header + +All + +nvrtc.h + +Windows + +nvrtc.dll, nvrtc-builtins.dll + +Mac OSX + +libnvrtc.dylib, libnvrtc-builtins.dylib + +Linux + +libnvrtc.so, libnvrtc-builtins.so + +Component + +NVIDIA Optimizing Compiler Library + +Windows + +nvvm.dll + +Mac OSX + +libnvvm.dylib + +Linux + +libnvvm.so + +Component + +NVIDIA Common Device Math Functions Library + +Windows + +libdevice.10.bc + +Mac OSX + +libdevice.10.bc + +Linux + +libdevice.10.bc + +Component + +CUDA Occupancy Calculation Header Library + +All + +cuda_occupancy.h + +Component + +CUDA Half Precision Headers + +All + +cuda_fp16.h, cuda_fp16.hpp + +Component + +CUDA Profiling Tools Interface (CUPTI) Library + +Windows + +cupti.dll + +Mac OSX + +libcupti.dylib + +Linux + +libcupti.so + +Component + +NVIDIA Tools Extension Library + +Windows + +nvToolsExt.dll, nvToolsExt.lib + +Mac OSX + +libnvToolsExt.dylib + +Linux + +libnvToolsExt.so + +Component + +NVIDIA CUDA Driver Libraries + +Linux + +libcuda.so, libnvidia-fatbinaryloader.so, +libnvidia-ptxjitcompiler.so + +The NVIDIA CUDA Driver Libraries are only distributable in +applications that meet this criteria: + + 1. The application was developed starting from a NVIDIA CUDA + container obtained from Docker Hub or the NVIDIA GPU + Cloud, and + + 2. The resulting application is packaged as a Docker + container and distributed to users on Docker Hub or the + NVIDIA GPU Cloud only. + + +2.7. Attachment B + + +Additional Licensing Obligations + +The following third party components included in the SOFTWARE +are licensed to Licensee pursuant to the following terms and +conditions: + + 1. Licensee's use of the GDB third party component is + subject to the terms and conditions of GNU GPL v3: + + This product includes copyrighted third-party software licensed + under the terms of the GNU General Public License v3 ("GPL v3"). + All third-party software packages are copyright by their respective + authors. GPL v3 terms and conditions are hereby incorporated into + the Agreement by this reference: http://www.gnu.org/licenses/gpl.txt + + Consistent with these licensing requirements, the software + listed below is provided under the terms of the specified + open source software licenses. To obtain source code for + software provided under licenses that require + redistribution of source code, including the GNU General + Public License (GPL) and GNU Lesser General Public License + (LGPL), contact oss-requests@nvidia.com. This offer is + valid for a period of three (3) years from the date of the + distribution of this product by NVIDIA CORPORATION. + + Component License + CUDA-GDB GPL v3 + + 2. Licensee represents and warrants that any and all third + party licensing and/or royalty payment obligations in + connection with Licensee's use of the H.264 video codecs + are solely the responsibility of Licensee. + + 3. Licensee's use of the Thrust library is subject to the + terms and conditions of the Apache License Version 2.0. + All third-party software packages are copyright by their + respective authors. Apache License Version 2.0 terms and + conditions are hereby incorporated into the Agreement by + this reference. + http://www.apache.org/licenses/LICENSE-2.0.html + + In addition, Licensee acknowledges the following notice: + Thrust includes source code from the Boost Iterator, + Tuple, System, and Random Number libraries. + + Boost Software License - Version 1.0 - August 17th, 2003 + . . . . + + Permission is hereby granted, free of charge, to any person or + organization obtaining a copy of the software and accompanying + documentation covered by this license (the "Software") to use, + reproduce, display, distribute, execute, and transmit the Software, + and to prepare derivative works of the Software, and to permit + third-parties to whom the Software is furnished to do so, all + subject to the following: + + The copyright notices in the Software and this entire statement, + including the above license grant, this restriction and the following + disclaimer, must be included in all copies of the Software, in whole + or in part, and all derivative works of the Software, unless such + copies or derivative works are solely in the form of machine-executable + object code generated by a source language processor. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND + NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR + OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + OTHER DEALINGS IN THE SOFTWARE. + + 4. Licensee's use of the LLVM third party component is + subject to the following terms and conditions: + + ====================================================== + LLVM Release License + ====================================================== + University of Illinois/NCSA + Open Source License + + Copyright (c) 2003-2010 University of Illinois at Urbana-Champaign. + All rights reserved. + + Developed by: + + LLVM Team + + University of Illinois at Urbana-Champaign + + http://llvm.org + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to + deal with the Software without restriction, including without limitation the + rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimers. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimers in the + documentation and/or other materials provided with the distribution. + + * Neither the names of the LLVM Team, University of Illinois at Urbana- + Champaign, nor the names of its contributors may be used to endorse or + promote products derived from this Software without specific prior + written permission. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS WITH THE SOFTWARE. + + 5. Licensee's use (e.g. nvprof) of the PCRE third party + component is subject to the following terms and + conditions: + + ------------ + PCRE LICENCE + ------------ + PCRE is a library of functions to support regular expressions whose syntax + and semantics are as close as possible to those of the Perl 5 language. + Release 8 of PCRE is distributed under the terms of the "BSD" licence, as + specified below. The documentation for PCRE, supplied in the "doc" + directory, is distributed under the same terms as the software itself. The + basic library functions are written in C and are freestanding. Also + included in the distribution is a set of C++ wrapper functions, and a just- + in-time compiler that can be used to optimize pattern matching. These are + both optional features that can be omitted when the library is built. + + THE BASIC LIBRARY FUNCTIONS + --------------------------- + Written by: Philip Hazel + Email local part: ph10 + Email domain: cam.ac.uk + University of Cambridge Computing Service, + Cambridge, England. + Copyright (c) 1997-2012 University of Cambridge + All rights reserved. + + PCRE JUST-IN-TIME COMPILATION SUPPORT + ------------------------------------- + Written by: Zoltan Herczeg + Email local part: hzmester + Emain domain: freemail.hu + Copyright(c) 2010-2012 Zoltan Herczeg + All rights reserved. + + STACK-LESS JUST-IN-TIME COMPILER + -------------------------------- + Written by: Zoltan Herczeg + Email local part: hzmester + Emain domain: freemail.hu + Copyright(c) 2009-2012 Zoltan Herczeg + All rights reserved. + + THE C++ WRAPPER FUNCTIONS + ------------------------- + Contributed by: Google Inc. + Copyright (c) 2007-2012, Google Inc. + All rights reserved. + + THE "BSD" LICENCE + ----------------- + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of the University of Cambridge nor the name of Google + Inc. nor the names of their contributors may be used to endorse or + promote products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + + 6. Some of the cuBLAS library routines were written by or + derived from code written by Vasily Volkov and are subject + to the Modified Berkeley Software Distribution License as + follows: + + Copyright (c) 2007-2009, Regents of the University of California + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the University of California, Berkeley nor + the names of its contributors may be used to endorse or promote + products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + + 7. Some of the cuBLAS library routines were written by or + derived from code written by Davide Barbieri and are + subject to the Modified Berkeley Software Distribution + License as follows: + + Copyright (c) 2008-2009 Davide Barbieri @ University of Rome Tor Vergata. + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * The name of the author may not be used to endorse or promote + products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR + IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + + 8. Some of the cuBLAS library routines were derived from + code developed by the University of Tennessee and are + subject to the Modified Berkeley Software Distribution + License as follows: + + Copyright (c) 2010 The University of Tennessee. + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer listed in this license in the documentation and/or + other materials provided with the distribution. + * Neither the name of the copyright holders nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 9. Some of the cuBLAS library routines were written by or + derived from code written by Jonathan Hogg and are subject + to the Modified Berkeley Software Distribution License as + follows: + + Copyright (c) 2012, The Science and Technology Facilities Council (STFC). + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the STFC nor the names of its contributors + may be used to endorse or promote products derived from this + software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE STFC BE + LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 10. Some of the cuBLAS library routines were written by or + derived from code written by Ahmad M. Abdelfattah, David + Keyes, and Hatem Ltaief, and are subject to the Apache + License, Version 2.0, as follows: + + -- (C) Copyright 2013 King Abdullah University of Science and Technology + Authors: + Ahmad Abdelfattah (ahmad.ahmad@kaust.edu.sa) + David Keyes (david.keyes@kaust.edu.sa) + Hatem Ltaief (hatem.ltaief@kaust.edu.sa) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the King Abdullah University of Science and + Technology nor the names of its contributors may be used to endorse + or promote products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE + + 11. Some of the cuSPARSE library routines were written by or + derived from code written by Li-Wen Chang and are subject + to the NCSA Open Source License as follows: + + Copyright (c) 2012, University of Illinois. + + All rights reserved. + + Developed by: IMPACT Group, University of Illinois, http://impact.crhc.illinois.edu + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal with the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimers in the documentation and/or other materials provided + with the distribution. + * Neither the names of IMPACT Group, University of Illinois, nor + the names of its contributors may be used to endorse or promote + products derived from this Software without specific prior + written permission. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT + HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER + IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR + IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE + SOFTWARE. + + 12. Some of the cuRAND library routines were written by or + derived from code written by Mutsuo Saito and Makoto + Matsumoto and are subject to the following license: + + Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima + University. All rights reserved. + + Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima + University and University of Tokyo. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the Hiroshima University nor the names of + its contributors may be used to endorse or promote products + derived from this software without specific prior written + permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 13. Some of the cuRAND library routines were derived from + code developed by D. E. Shaw Research and are subject to + the following license: + + Copyright 2010-2011, D. E. Shaw Research. + + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions, and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions, and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of D. E. Shaw Research nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 14. Some of the Math library routines were written by or + derived from code developed by Norbert Juffa and are + subject to the following license: + + Copyright (c) 2015-2017, Norbert Juffa + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 15. Licensee's use of the lz4 third party component is + subject to the following terms and conditions: + + Copyright (C) 2011-2013, Yann Collet. + BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php) + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + 16. The NPP library uses code from the Boost Math Toolkit, + and is subject to the following license: + + Boost Software License - Version 1.0 - August 17th, 2003 + . . . . + + Permission is hereby granted, free of charge, to any person or + organization obtaining a copy of the software and accompanying + documentation covered by this license (the "Software") to use, + reproduce, display, distribute, execute, and transmit the Software, + and to prepare derivative works of the Software, and to permit + third-parties to whom the Software is furnished to do so, all + subject to the following: + + The copyright notices in the Software and this entire statement, + including the above license grant, this restriction and the following + disclaimer, must be included in all copies of the Software, in whole + or in part, and all derivative works of the Software, unless such + copies or derivative works are solely in the form of machine-executable + object code generated by a source language processor. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND + NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR + OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + OTHER DEALINGS IN THE SOFTWARE. + + 17. Portions of the Nsight Eclipse Edition is subject to the + following license: + + The Eclipse Foundation makes available all content in this plug-in + ("Content"). Unless otherwise indicated below, the Content is provided + to you under the terms and conditions of the Eclipse Public License + Version 1.0 ("EPL"). A copy of the EPL is available at http:// + www.eclipse.org/legal/epl-v10.html. For purposes of the EPL, "Program" + will mean the Content. + + If you did not receive this Content directly from the Eclipse + Foundation, the Content is being redistributed by another party + ("Redistributor") and different terms and conditions may apply to your + use of any object code in the Content. Check the Redistributor's + license that was provided with the Content. If no such license exists, + contact the Redistributor. Unless otherwise indicated below, the terms + and conditions of the EPL still apply to any source code in the + Content and such source code may be obtained at http://www.eclipse.org. + + 18. Some of the cuBLAS library routines uses code from + OpenAI, which is subject to the following license: + + License URL + https://github.com/openai/openai-gemm/blob/master/LICENSE + + License Text + The MIT License + + Copyright (c) 2016 OpenAI (http://openai.com), 2016 Google Inc. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + + 19. Licensee's use of the Visual Studio Setup Configuration + Samples is subject to the following license: + + The MIT License (MIT) + Copyright (C) Microsoft Corporation. All rights reserved. + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation + files (the "Software"), to deal in the Software without restriction, + including without limitation the rights to use, copy, modify, merge, + publish, distribute, sublicense, and/or sell copies of the Software, + and to permit persons to whom the Software is furnished to do so, + subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + 20. Licensee's use of linmath.h header for CPU functions for + GL vector/matrix operations from lunarG is subject to the + Apache License Version 2.0. + + 21. The DX12-CUDA sample uses the d3dx12.h header, which is + subject to the MIT license . + +----------------- diff --git a/.venv/lib/python3.12/site-packages/nvidia_cuda_runtime_cu12-12.8.90.dist-info/METADATA b/.venv/lib/python3.12/site-packages/nvidia_cuda_runtime_cu12-12.8.90.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..14b471170862b26f1dc2b83800d568d5c38533ec --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cuda_runtime_cu12-12.8.90.dist-info/METADATA @@ -0,0 +1,44 @@ +Metadata-Version: 2.2 +Name: nvidia-cuda-runtime-cu12 +Version: 12.8.90 +Summary: CUDA Runtime native Libraries +Home-page: https://developer.nvidia.com/cuda-zone +Author: Nvidia CUDA Installer Team +Author-email: compute_installer@nvidia.com +License: NVIDIA Proprietary Software +Keywords: cuda,nvidia,runtime,machine learning,deep learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: Other/Proprietary License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Requires-Python: >=3 +License-File: License.txt +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: home-page +Dynamic: keywords +Dynamic: license +Dynamic: requires-python +Dynamic: summary + +CUDA Runtime native Libraries diff --git a/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/METADATA b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..4d22d2b0a860e67abb882c6ec18c0a5dc468a39f --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/METADATA @@ -0,0 +1,44 @@ +Metadata-Version: 2.2 +Name: nvidia-cufile-cu12 +Version: 1.13.1.3 +Summary: cuFile GPUDirect libraries +Home-page: https://developer.nvidia.com/cuda-zone +Author: Nvidia CUDA Installer Team +Author-email: compute_installer@nvidia.com +License: NVIDIA Proprietary Software +Keywords: cuda,nvidia,runtime,machine learning,deep learning +Classifier: Development Status :: 4 - Beta +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Science/Research +Classifier: License :: Other/Proprietary License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Scientific/Engineering +Classifier: Topic :: Scientific/Engineering :: Mathematics +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development +Classifier: Topic :: Software Development :: Libraries +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX :: Linux +Requires-Python: >=3 +License-File: License.txt +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: home-page +Dynamic: keywords +Dynamic: license +Dynamic: requires-python +Dynamic: summary + +cuFile GPUDirect libraries diff --git a/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..287a9d7e1a3d4435e9542cc8216b8c5eaf2c0ed2 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.8.0) +Root-Is-Purelib: true +Tag: py3-none-manylinux2014_x86_64 +Tag: py3-none-manylinux_2_17_x86_64 + diff --git a/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cufile_cu12-1.13.1.3.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/.venv/lib/python3.12/site-packages/nvidia_curand_cu12-10.3.9.90.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/nvidia_curand_cu12-10.3.9.90.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_curand_cu12-10.3.9.90.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/nvidia_curand_cu12-10.3.9.90.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/nvidia_curand_cu12-10.3.9.90.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_curand_cu12-10.3.9.90.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..711dd0f79fe712cec60be7868740cd7d73ccb637 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.8.1) +Root-Is-Purelib: true +Tag: py3-none-manylinux2014_x86_64 +Tag: py3-none-manylinux_2_17_x86_64 + diff --git a/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_cusparse_cu12-12.5.8.93.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/RECORD b/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..b40de80dba1ef3dd1975fd1b70e1537075ea480c --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/RECORD @@ -0,0 +1,8 @@ +nvidia/nccl/include/nccl.h,sha256=a-E7PcjbKHPqQfuDKjT5Mt9fDxwv32LNIpOtJyxBv94,22566 +nvidia/nccl/lib/libnccl.so.2,sha256=H8Nu68hPSxCSPu4hU47Y-iVyVkfQb0hAvA_jmabtm8Q,429634192 +nvidia_nccl_cu12-2.27.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +nvidia_nccl_cu12-2.27.3.dist-info/METADATA,sha256=h-6ZnFWjGBdh9Ld1ijhVOXdrDLo82k_Q-L_02ibG41U,2019 +nvidia_nccl_cu12-2.27.3.dist-info/RECORD,, +nvidia_nccl_cu12-2.27.3.dist-info/WHEEL,sha256=gy6FWQgpujK_dnYc155G2NL32NQjpi5ebTEXjh8SGZQ,144 +nvidia_nccl_cu12-2.27.3.dist-info/licenses/License.txt,sha256=DwF0prTgszrCY3W_cpUzB1sy9MUaW2gCo9dC19zcmnY,1895 +nvidia_nccl_cu12-2.27.3.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7 diff --git a/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..29738220b339f398b2cbbc9ac8ccb38a39bdd7b2 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (80.9.0) +Root-Is-Purelib: true +Tag: py3-none-manylinux2014_x86_64 +Tag: py3-none-manylinux_2_17_x86_64 + diff --git a/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..862f7abf232cdfbb928609856247292e81c9decb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/nvidia_nccl_cu12-2.27.3.dist-info/top_level.txt @@ -0,0 +1 @@ +nvidia diff --git a/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/RECORD b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..174ea270178a11b6ce74f912471cdbccbcea47d5 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/RECORD @@ -0,0 +1,236 @@ +PIL/AvifImagePlugin.py,sha256=5IiDMvMZQXLnS3t25XJjlwgNWmeVSNaGfReWAp-V5lo,8994 +PIL/BdfFontFile.py,sha256=PhlZfIRmEfmorbhZZeSM5eebGo1Ei7fL-lR9XlfTZZA,3285 +PIL/BlpImagePlugin.py,sha256=Ub4vVKBEniiNBEgNizxScEpO1VKbC1w6iecWUU7T-Vs,16533 +PIL/BmpImagePlugin.py,sha256=-SNdj2godmaKYAc08dEng6z3mRPbYYHezjveIR5e-tU,19855 +PIL/BufrStubImagePlugin.py,sha256=JSqDhkPNPnFw0Qcz-gQJl-D_iSCFdtcLvPynshKJ4WM,1730 +PIL/ContainerIO.py,sha256=wkBqL2GDAb5fh3wrtfTGUfqioJipCl-lg2GxbjQrTZw,4604 +PIL/CurImagePlugin.py,sha256=-WEsgwQbA9rQzXB0HG0LK1V_qbuwHosPZ0T2IjfN8r0,1791 +PIL/DcxImagePlugin.py,sha256=DhqsmW7MjmnUSTGZ-Skv9hz1XeX3XoQQoAl9GWLAEEY,2145 +PIL/DdsImagePlugin.py,sha256=fjdfZK_eQtUp_-bjoRmt-5wgOT5GTmvg6aI-itch4mo,18906 +PIL/EpsImagePlugin.py,sha256=Q91Of8yr6VY12picGSU6k6HvgU9FgnQJvWrJQryiLnU,16552 +PIL/ExifTags.py,sha256=zW6kVikCosiyoCo7J7R62evD3hoxjKPchnVh8po7CZc,9931 +PIL/FitsImagePlugin.py,sha256=-oDJnAH113CK5qPvwz9lL81fkV1gla_tNfqLcq8zKgo,4644 +PIL/FliImagePlugin.py,sha256=4zxH8IXBX9DGi6dJRM6Y5NMdbA1d99x696mcGZHxHzI,4929 +PIL/FontFile.py,sha256=St7MxO5Q-oakCLWn3ZrgrtaT3wSsmAarxm8AU-G8Moc,3577 +PIL/FpxImagePlugin.py,sha256=aXfg0YdvNeJhxqh-f-f22D1NobQ8tSVCj-tpLE2PKfE,7293 +PIL/FtexImagePlugin.py,sha256=v2I5YkdfNA3iW35JzKnWry9v6Rgvr0oezGVOuArREac,3535 +PIL/GbrImagePlugin.py,sha256=ADLgy4hlBcC_3Rr2HsnIuXPoUvof1ddkhbEo5Yw8OMQ,2979 +PIL/GdImageFile.py,sha256=LP4Uxv3Y2ivGZIyOVuGJarDDVS7zK6F1Q6SNl4wyGuQ,2788 +PIL/GifImagePlugin.py,sha256=VNTEgDJRP6OIze8JVt0EXY1gMv3Xx90oECxawggCFAE,42213 +PIL/GimpGradientFile.py,sha256=gqqUkDbKVFCtBxt5VAhPS0HtLZDYFI6KWEaUhhTNNE8,3982 +PIL/GimpPaletteFile.py,sha256=hIHQ9LJ5ri0hy1e_vZYeD-n67UWdhEDlKc4vDxgaUdg,1860 +PIL/GribStubImagePlugin.py,sha256=I-_ZlKsSKANo7adUTnIx7pTUhQt-0B60DacLDOVm_3E,1759 +PIL/Hdf5StubImagePlugin.py,sha256=OuEQijGqVwTTSG4dB2vAyQzmN-NYT22tiuZHFH0Q0Sw,1741 +PIL/IcnsImagePlugin.py,sha256=dr_p68k2ECoONrw3Dqw3ISig39uXo39YY3nTfshUNHw,12405 +PIL/IcoImagePlugin.py,sha256=QCo29Toh08UX8vEcdCAaIeuidSolbPiZlCnQ4rUu2SQ,12491 +PIL/ImImagePlugin.py,sha256=wo5OL2PAcQW2MwRkJnS-N16toZzXWL95jx9FBM7l9ok,11567 +PIL/Image.py,sha256=2naP8UMkmSyU64EFc5crz4t02nV4f8ptFKfZdvbtBHQ,148085 +PIL/ImageChops.py,sha256=GEjlymcoDtA5OOeIxQVIX96BD-s6AXhb7TmSLYn2tUg,7946 +PIL/ImageCms.py,sha256=IuCm3gXKpb5Eu1kn-TB8cD9XJLZEa8fpkEjzVqAIKNk,40676 +PIL/ImageColor.py,sha256=IGA9C2umeED_EzS2Cvj6KsU0VutC9RstWIYPe8uDsVk,9441 +PIL/ImageDraw.py,sha256=FMn0AK_gxxJBYB8afOGF2FUP2KJPFvUf3UZp_KrJz7A,36287 +PIL/ImageDraw2.py,sha256=pdVMW7bVw3KwhXvRZh28Md4y-2xFfuo5fHcDnaYqVK4,7227 +PIL/ImageEnhance.py,sha256=4Elhz_lyyxLmx0GkSHrwOAmNJ2TkqVQPHejzGihZUMI,3627 +PIL/ImageFile.py,sha256=m6Se6q-5zsmnE7Bezp13q-H5F2yt5d4tO7YD06FGHx4,29600 +PIL/ImageFilter.py,sha256=MO1MBrbXDiX2IAGESdGm_0087bwmSZ_14ecAj28ojCY,18729 +PIL/ImageFont.py,sha256=2PGC3YI127GKrXYg4zP7_Tul2KCQ3c4ajU8LONVO9bc,63101 +PIL/ImageGrab.py,sha256=I9PHpsQf2VyNX4T8QL-8awFNotyAzB1mGxTt_I5FbTE,6471 +PIL/ImageMath.py,sha256=RQl6cRXGuszba4KwtbIudin_8U65shpWrajr9gTn1rw,10369 +PIL/ImageMode.py,sha256=aaZVHAiCEanOA2K1jN3DlW3NPKa8Dm5nIXTXErzyFms,2395 +PIL/ImageMorph.py,sha256=dobO2v2w7c8SjH7stFc3TP6HtU9O7JAWQz5Nu6mBxYg,8562 +PIL/ImageOps.py,sha256=bIcQFK_MtovfNSYTcOesp4So9OgsGrwt3cGsB7xlGRM,25567 +PIL/ImagePalette.py,sha256=M5tYUgadWR7mxUEByyVl7IV9QFFzAGiKKmAhCZtdG0w,9009 +PIL/ImagePath.py,sha256=5yUG5XCUil1KKTTA_8PgGhcmg-mnue-GK0FwTBlhjw4,371 +PIL/ImageQt.py,sha256=PTt5TPyngWL-Vuvx_bwnH17EOBe3tE7l4huVmvGQP5Y,6684 +PIL/ImageSequence.py,sha256=Mphgkr79scmYBgmi9ZguhDfVwHvpLSX5uZVHDZlrn0I,2253 +PIL/ImageShow.py,sha256=Ju0_Db2B4_n3yKJV9sDsF7_HAgciEdXlq6I1Eiw1YTo,10106 +PIL/ImageStat.py,sha256=FVTiYWGCciPW1QD61b7DYZlcDqR0dS6hsLjq-gcKcG4,5495 +PIL/ImageText.py,sha256=rkdTrW6pQCquXFOTu_0OoBfvCYiC9zQG__8JjGwnPYE,12103 +PIL/ImageTk.py,sha256=b5SntckGXs0ECsI2MmdJg3CSX6AtELsWh0Ohxu41u_k,8132 +PIL/ImageTransform.py,sha256=-qek7P3lzLddcXt9cWt5w_L11JGp2yY3AJtOfmJAkDc,3916 +PIL/ImageWin.py,sha256=LT05w8_vTfRrC3n9S9pM0TNbXrzZLEJHlCJil7Xv80k,8085 +PIL/ImtImagePlugin.py,sha256=SL5IrsHcblltxtX4v_HVFhYnR6haJ0AOd2NHhZKMImY,2665 +PIL/IptcImagePlugin.py,sha256=cOFy4epsqpMOWNgQ3Gj_dOrt2TPjbO0gjCvp_f1mUxk,6444 +PIL/Jpeg2KImagePlugin.py,sha256=IabyXVrNchWV9oOUU79eNjGSudq5tlvnihFimZH4VAA,13932 +PIL/JpegImagePlugin.py,sha256=ZMvTMZTxi2UHu87NXauQmhLC3tWEMxa2CgUhYcFq7yw,31318 +PIL/JpegPresets.py,sha256=lnqWHo4DLIHIulcdHp0NJ7CWexHt8T3w51kIKlLfkIA,12379 +PIL/McIdasImagePlugin.py,sha256=baOIkD-CIIeCgBFTf8kos928PKBuCUqYYa38u3WES_8,1877 +PIL/MicImagePlugin.py,sha256=aoIwkWVyr_X-dPvB6ldZOJF3a9kd_OeuEW3say5Y0QM,2564 +PIL/MpegImagePlugin.py,sha256=g7BZd93kWpFi41SG_wKFoi0yEPsioI4kj45b2F-3Vrw,2010 +PIL/MpoImagePlugin.py,sha256=S45qt7OcY7rBjYlwEk0nUmEj5IOu5z8KVLo066V1RBE,6722 +PIL/MspImagePlugin.py,sha256=oxk_MLUDvzJ4JDuOZCHkmqOPXniG42PHOyNGwe60slY,5892 +PIL/PSDraw.py,sha256=KMBGj3vXaFpblaIcA9KjFFTpdal41AQggY-UgzqoMkQ,6918 +PIL/PaletteFile.py,sha256=suDdAL6VMljXw4oEn1vhTt4DQ4vbpIHGd3A4oxOgE6s,1216 +PIL/PalmImagePlugin.py,sha256=WJ1b8I1xTSAXYDJhIpkVFCLu2LlpbiBD5d1Hr-m2l08,8748 +PIL/PcdImagePlugin.py,sha256=-gnMUqQH0R-aljsd3nZS9eBI1j75ijWD_HZfadE3RsQ,1774 +PIL/PcfFontFile.py,sha256=DqcyydQgP2vtiPFzj57KYHLuF2v-0oMTB-VkgYYHKhE,7223 +PIL/PcxImagePlugin.py,sha256=1xAq6CdH34cOsOgTPi4Wu2SKQCdQiTLVyqaMkYQZUP4,6245 +PIL/PdfImagePlugin.py,sha256=6lZLoQMVbAE-x1ESrv6PgGSyM9Ueck7e6E6ps-YQ-vI,9321 +PIL/PdfParser.py,sha256=Hr3ImLDSIKwUF6OrQ1GjlAnGi6ZpGVLWhGfKhqQ_DRM,37996 +PIL/PixarImagePlugin.py,sha256=l_4GwBd0mATnIXYJbwmmODU2vP7wewLu6BRviHCB2EI,1758 +PIL/PngImagePlugin.py,sha256=jGtbaGMrt9x0i9c500Nh1ofQ4M6w23Wlu67oTuwYEIA,51144 +PIL/PpmImagePlugin.py,sha256=vb5SP0IjQPzDRDE8jSPtcJv9K3Rh1LczAlt0Pg26i90,12391 +PIL/PsdImagePlugin.py,sha256=ImnNRG4VANs2GATXVEB5Q-yy1Jskc6XRVRtZYi2fALg,8685 +PIL/QoiImagePlugin.py,sha256=RPO63QsgHAsyPpcxh7ymeMYlnjVu5gT5ELolkvJt0vc,8572 +PIL/SgiImagePlugin.py,sha256=3Ql89s8vycNWjcxJwMw28iksV9Yj2xWoKBQ6c5DHXBg,6389 +PIL/SpiderImagePlugin.py,sha256=Bsg6pfZMctas1xYx__oL-ZZseUReZdnLy5a-aKEJhpE,10249 +PIL/SunImagePlugin.py,sha256=Hdxkhk0pxpBGxYhPJfCDLwsYcO1KjxjtplNMFYibIvk,4589 +PIL/TarIO.py,sha256=BqYUChCBb9F7Sh-uZ86iz1Dtoy2D0obNwGm65z1rdc0,1442 +PIL/TgaImagePlugin.py,sha256=2vDsFTcBUBHw1V80wpVv4tgpLDbPr6yVHi6Fvaqf0HY,6980 +PIL/TiffImagePlugin.py,sha256=cIQ48x3zmm5PFSG01wqweC8DJUhJxrX1R62c8Edw1Jg,85002 +PIL/TiffTags.py,sha256=cMmOVPxiq8Yt99J9DEQz4tXu8IZvsJFCSL3zJDGw3fM,17251 +PIL/WalImageFile.py,sha256=4o52MngMxr9dlMmCyIXu-11-QpEN6-MRcJnEfyjdc4M,5687 +PIL/WebPImagePlugin.py,sha256=h8hosK6SWJ5tAuSFFCboKTJ_dQCFthCGT9ooYq6TVCk,10054 +PIL/WmfImagePlugin.py,sha256=y1z3RPYozRQY8AOEs-iark--cv835yF9xENm7b0GNXo,5244 +PIL/XVThumbImagePlugin.py,sha256=cJSapkBasFt11O6XYXxqcyA-njxA5BD3wHhNj6VC7Fk,2115 +PIL/XbmImagePlugin.py,sha256=Fd6GVDEo73nyFICA3Z3w4LjkwoZWvhHB6rKCm5yVrho,2669 +PIL/XpmImagePlugin.py,sha256=jtUKavJCYwIAsJaJwSx8vJsx1oTbCywfDxePENmA93w,4400 +PIL/__init__.py,sha256=Q4KOEpR7S_Xsj30fvOsvR94xEpX4KUsVeUwaVP1fU80,2031 +PIL/__main__.py,sha256=Lpj4vef8mI7jA1sRCUAoVYaeePD_Uc898xF5c7XLx1A,133 +PIL/__pycache__/AvifImagePlugin.cpython-312.pyc,, +PIL/__pycache__/BdfFontFile.cpython-312.pyc,, +PIL/__pycache__/BlpImagePlugin.cpython-312.pyc,, +PIL/__pycache__/BmpImagePlugin.cpython-312.pyc,, +PIL/__pycache__/BufrStubImagePlugin.cpython-312.pyc,, +PIL/__pycache__/ContainerIO.cpython-312.pyc,, +PIL/__pycache__/CurImagePlugin.cpython-312.pyc,, +PIL/__pycache__/DcxImagePlugin.cpython-312.pyc,, +PIL/__pycache__/DdsImagePlugin.cpython-312.pyc,, +PIL/__pycache__/EpsImagePlugin.cpython-312.pyc,, +PIL/__pycache__/ExifTags.cpython-312.pyc,, +PIL/__pycache__/FitsImagePlugin.cpython-312.pyc,, +PIL/__pycache__/FliImagePlugin.cpython-312.pyc,, +PIL/__pycache__/FontFile.cpython-312.pyc,, +PIL/__pycache__/FpxImagePlugin.cpython-312.pyc,, +PIL/__pycache__/FtexImagePlugin.cpython-312.pyc,, +PIL/__pycache__/GbrImagePlugin.cpython-312.pyc,, +PIL/__pycache__/GdImageFile.cpython-312.pyc,, +PIL/__pycache__/GifImagePlugin.cpython-312.pyc,, +PIL/__pycache__/GimpGradientFile.cpython-312.pyc,, +PIL/__pycache__/GimpPaletteFile.cpython-312.pyc,, +PIL/__pycache__/GribStubImagePlugin.cpython-312.pyc,, +PIL/__pycache__/Hdf5StubImagePlugin.cpython-312.pyc,, +PIL/__pycache__/IcnsImagePlugin.cpython-312.pyc,, +PIL/__pycache__/IcoImagePlugin.cpython-312.pyc,, +PIL/__pycache__/ImImagePlugin.cpython-312.pyc,, +PIL/__pycache__/Image.cpython-312.pyc,, +PIL/__pycache__/ImageChops.cpython-312.pyc,, +PIL/__pycache__/ImageCms.cpython-312.pyc,, +PIL/__pycache__/ImageColor.cpython-312.pyc,, +PIL/__pycache__/ImageDraw.cpython-312.pyc,, +PIL/__pycache__/ImageDraw2.cpython-312.pyc,, +PIL/__pycache__/ImageEnhance.cpython-312.pyc,, +PIL/__pycache__/ImageFile.cpython-312.pyc,, +PIL/__pycache__/ImageFilter.cpython-312.pyc,, +PIL/__pycache__/ImageFont.cpython-312.pyc,, +PIL/__pycache__/ImageGrab.cpython-312.pyc,, +PIL/__pycache__/ImageMath.cpython-312.pyc,, +PIL/__pycache__/ImageMode.cpython-312.pyc,, +PIL/__pycache__/ImageMorph.cpython-312.pyc,, +PIL/__pycache__/ImageOps.cpython-312.pyc,, +PIL/__pycache__/ImagePalette.cpython-312.pyc,, +PIL/__pycache__/ImagePath.cpython-312.pyc,, +PIL/__pycache__/ImageQt.cpython-312.pyc,, +PIL/__pycache__/ImageSequence.cpython-312.pyc,, +PIL/__pycache__/ImageShow.cpython-312.pyc,, +PIL/__pycache__/ImageStat.cpython-312.pyc,, +PIL/__pycache__/ImageText.cpython-312.pyc,, +PIL/__pycache__/ImageTk.cpython-312.pyc,, +PIL/__pycache__/ImageTransform.cpython-312.pyc,, +PIL/__pycache__/ImageWin.cpython-312.pyc,, +PIL/__pycache__/ImtImagePlugin.cpython-312.pyc,, +PIL/__pycache__/IptcImagePlugin.cpython-312.pyc,, +PIL/__pycache__/Jpeg2KImagePlugin.cpython-312.pyc,, +PIL/__pycache__/JpegImagePlugin.cpython-312.pyc,, +PIL/__pycache__/JpegPresets.cpython-312.pyc,, +PIL/__pycache__/McIdasImagePlugin.cpython-312.pyc,, +PIL/__pycache__/MicImagePlugin.cpython-312.pyc,, +PIL/__pycache__/MpegImagePlugin.cpython-312.pyc,, +PIL/__pycache__/MpoImagePlugin.cpython-312.pyc,, +PIL/__pycache__/MspImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PSDraw.cpython-312.pyc,, +PIL/__pycache__/PaletteFile.cpython-312.pyc,, +PIL/__pycache__/PalmImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PcdImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PcfFontFile.cpython-312.pyc,, +PIL/__pycache__/PcxImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PdfImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PdfParser.cpython-312.pyc,, +PIL/__pycache__/PixarImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PngImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PpmImagePlugin.cpython-312.pyc,, +PIL/__pycache__/PsdImagePlugin.cpython-312.pyc,, +PIL/__pycache__/QoiImagePlugin.cpython-312.pyc,, +PIL/__pycache__/SgiImagePlugin.cpython-312.pyc,, +PIL/__pycache__/SpiderImagePlugin.cpython-312.pyc,, +PIL/__pycache__/SunImagePlugin.cpython-312.pyc,, +PIL/__pycache__/TarIO.cpython-312.pyc,, +PIL/__pycache__/TgaImagePlugin.cpython-312.pyc,, +PIL/__pycache__/TiffImagePlugin.cpython-312.pyc,, +PIL/__pycache__/TiffTags.cpython-312.pyc,, +PIL/__pycache__/WalImageFile.cpython-312.pyc,, +PIL/__pycache__/WebPImagePlugin.cpython-312.pyc,, +PIL/__pycache__/WmfImagePlugin.cpython-312.pyc,, +PIL/__pycache__/XVThumbImagePlugin.cpython-312.pyc,, +PIL/__pycache__/XbmImagePlugin.cpython-312.pyc,, +PIL/__pycache__/XpmImagePlugin.cpython-312.pyc,, +PIL/__pycache__/__init__.cpython-312.pyc,, +PIL/__pycache__/__main__.cpython-312.pyc,, +PIL/__pycache__/_binary.cpython-312.pyc,, +PIL/__pycache__/_deprecate.cpython-312.pyc,, +PIL/__pycache__/_tkinter_finder.cpython-312.pyc,, +PIL/__pycache__/_typing.cpython-312.pyc,, +PIL/__pycache__/_util.cpython-312.pyc,, +PIL/__pycache__/_version.cpython-312.pyc,, +PIL/__pycache__/features.cpython-312.pyc,, +PIL/__pycache__/report.cpython-312.pyc,, +PIL/_avif.cpython-312-x86_64-linux-gnu.so,sha256=yRNgSy1InaliqpKaMpMB9kHUhxRQbzzTpnlR2l6oEQ0,87889 +PIL/_avif.pyi,sha256=3fBxcSppJr6EOEcUojvflG3Eegg7lv2Qp0dNQQILrP4,63 +PIL/_binary.py,sha256=pcM6AL04GxgmGeLfcH1V1BZHENwIrQH0uxhJ7r0HIL0,2550 +PIL/_deprecate.py,sha256=2t747uUfRLL0rYxIEvykqyDaB_1b0eDSnwgpTh5O5fI,1970 +PIL/_imaging.cpython-312-x86_64-linux-gnu.so,sha256=Qms5ezxg57fSuA28sxPtzkGFUZY51Eskgn9xDxRv854,3353449 +PIL/_imaging.pyi,sha256=StMbXUZS32AegATP1sUHfs5P05A3TD_BiQKsDHQBW40,868 +PIL/_imagingcms.cpython-312-x86_64-linux-gnu.so,sha256=N5l4nrEfJm1eTqp9-_4jSPpECVmkaBj704jWvdboDiE,157841 +PIL/_imagingcms.pyi,sha256=ZZ8iIoi6EHWLvgAdfm1hPD5CQmxi75LiJl5x8yGxYoU,4433 +PIL/_imagingft.cpython-312-x86_64-linux-gnu.so,sha256=P4nOgLlBXt1HUx5gY_NZTO9_Q6va_XbL9Vbr2eeKz2s,322977 +PIL/_imagingft.pyi,sha256=cYySzvcKBCiHPBsvttMie9AdfUcEsqZR-3256YQtz2Q,1833 +PIL/_imagingmath.cpython-312-x86_64-linux-gnu.so,sha256=XeFGcZNLFqbC46rmYI-lrJDHeI7izej58TFwOyaj0p4,167584 +PIL/_imagingmath.pyi,sha256=3fBxcSppJr6EOEcUojvflG3Eegg7lv2Qp0dNQQILrP4,63 +PIL/_imagingmorph.cpython-312-x86_64-linux-gnu.so,sha256=QecKvnGpy2TtOUM0M6SWwLnvUkXHAqb47qnnte0oIOY,37088 +PIL/_imagingmorph.pyi,sha256=3fBxcSppJr6EOEcUojvflG3Eegg7lv2Qp0dNQQILrP4,63 +PIL/_imagingtk.cpython-312-x86_64-linux-gnu.so,sha256=WGAwYKWjYKgfbdAKf16LyYrhUrCB3Y3hWVQVZLvNwBA,47048 +PIL/_imagingtk.pyi,sha256=3fBxcSppJr6EOEcUojvflG3Eegg7lv2Qp0dNQQILrP4,63 +PIL/_tkinter_finder.py,sha256=GIZ4stmFhUosmHKSrdxcjStiocDNfyJn7RBie2SWxU0,538 +PIL/_typing.py,sha256=2z33ZUp9aQnkSqXzNR3Zn7l04d2W-oAj1OiZhiyFF68,919 +PIL/_util.py,sha256=fxhWdrLARyc2PsMgN3m9_U1dY3oUKbV7mkoHcXgoeeA,684 +PIL/_version.py,sha256=OYLJ24lJylQ6NFpzq3LMRSnDyAJmp1pnFQ_c3PMZR44,87 +PIL/_webp.cpython-312-x86_64-linux-gnu.so,sha256=F1C2ZfPaEyKi891Xn5miD6BPphtTgChsvRD5vuyvtF4,108849 +PIL/_webp.pyi,sha256=3fBxcSppJr6EOEcUojvflG3Eegg7lv2Qp0dNQQILrP4,63 +PIL/features.py,sha256=FPkEhjtBaRSqpkgHNYduwxiFtycu4NjZKwEMWxtemPU,10775 +PIL/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +PIL/report.py,sha256=4JY6-IU7sH1RKuRbOvy1fUt0dAoi79FX4tYJN3p1DT0,100 +pillow-12.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +pillow-12.0.0.dist-info/METADATA,sha256=rWIEUr-lPL-ilNfae2bataCGpU7eDOF4vXTjgOvENMg,8808 +pillow-12.0.0.dist-info/RECORD,, +pillow-12.0.0.dist-info/WHEEL,sha256=1crAxrAH5rUbvWUY1UR0ly3o7KnT1jo0_98V8RY5-FM,152 +pillow-12.0.0.dist-info/licenses/LICENSE,sha256=MBeL96_5-NyCr-01CGzTeKkGTnf8tDgEhfOLXaM3cFI,68061 +pillow-12.0.0.dist-info/top_level.txt,sha256=riZqrk-hyZqh5f1Z0Zwii3dKfxEsByhu9cU9IODF-NY,4 +pillow-12.0.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 +pillow.libs/libXau-154567c4.so.6.0.0,sha256=BUhNJL94y47QMWnxywZyBNgpy3ryHeiCBADSnRFeQyA,22081 +pillow.libs/libavif-01e67780.so.16.3.0,sha256=xCXlA8_rggzsCA_EsWKFzgqPBmT1ihpZCo3iMyvD1P0,5142057 +pillow.libs/libbrotlicommon-c55a5f7a.so.1.1.0,sha256=HaLbMm3YehX759wgF7ZU0kVwhdgX4ukfvQNKytoarw8,144425 +pillow.libs/libbrotlidec-2ced2f3a.so.1.1.0,sha256=BOwekVTiRipkYusnBXmzGGhiPsBwBI6DDWPLkvxAbRE,62337 +pillow.libs/libfreetype-5bb46249.so.6.20.4,sha256=Tg7wTbDEPfL0YvLbadZ40tNwy4fKxjhuxuCsaDHzCrw,1463609 +pillow.libs/libharfbuzz-525aa570.so.0.61210.0,sha256=HyXdr1Fa9eEK7Q3VvhhzDw8DA-kp-BjzV6Ql5oX-lbc,941033 +pillow.libs/libjpeg-a41b0190.so.62.4.0,sha256=nMxHb3xGeNHn_aC68P7_-TP__RdUvJooSl_7JEFa1mU,836273 +pillow.libs/liblcms2-cc10e42f.so.2.0.17,sha256=5JMjEDVKMwxcinhbQl6qhRLaezAiQFYEPSz-KultHe0,519073 +pillow.libs/liblzma-64b7ab39.so.5.8.1,sha256=hN2B2RPEM6wOgvER_g43fNjbNQ_SsrenX2wlAfHW-nA,266369 +pillow.libs/libopenjp2-94e588ba.so.2.5.4,sha256=5ye2mwzPYSo447VzscBGO_ZWXyBgFEPFRY45hlXLIw0,585849 +pillow.libs/libpng16-00127801.so.16.50.0,sha256=KIB4XEQDJkGL2nMIrURzNgiSxMwl87FIyB0em53ffx8,278001 +pillow.libs/libsharpyuv-95d8a097.so.0.1.2,sha256=EtR2hzr_XVKswxcXrVFfDixKeUd1TMu56F0oHwH3Els,46113 +pillow.libs/libtiff-295fd75c.so.6.2.0,sha256=fkRD5oAmt0kNw9iL_CfKz0aqsJ3AgnDyVs1U0CRkEZU,754729 +pillow.libs/libwebp-d8b9687f.so.7.2.0,sha256=k-gbdtoXnzmBItYhvYxdhV11ff08TsQgWSMUUHmMzPs,731209 +pillow.libs/libwebpdemux-747f2b49.so.2.0.17,sha256=jsiJz7rjNfyn9TOqFT2OPydmTYax0iNBCCBQg9st9vw,30217 +pillow.libs/libwebpmux-7f11e5ce.so.3.1.2,sha256=Pes9BQ-MFyCzlQH9n07pWNtt7O0afgVlBsMJ-6kuU_o,58617 +pillow.libs/libxcb-64009ff3.so.1.1.0,sha256=t0N-0WuuesRJgEn9FOENG9HD59FdDl6rHS6tQqg6SdE,251425 +pillow.libs/libzstd-761a17b6.so.1.5.7,sha256=jKEGQObGqZaFbxpkGZX8jzstJVcHhJPh4SShnGgZjB8,1800497 diff --git a/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..b338169ce0c740c335bfe82912227ae8637bd492 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/top_level.txt @@ -0,0 +1 @@ +PIL diff --git a/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/zip-safe b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/zip-safe new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/.venv/lib/python3.12/site-packages/pillow-12.0.0.dist-info/zip-safe @@ -0,0 +1 @@ + diff --git a/.venv/lib/python3.12/site-packages/pillow.libs/libbrotlidec-2ced2f3a.so.1.1.0 b/.venv/lib/python3.12/site-packages/pillow.libs/libbrotlidec-2ced2f3a.so.1.1.0 new file mode 100644 index 0000000000000000000000000000000000000000..2d8d8b9c679d2225a7e9be93be105b15171219e2 Binary files /dev/null and b/.venv/lib/python3.12/site-packages/pillow.libs/libbrotlidec-2ced2f3a.so.1.1.0 differ diff --git a/.venv/lib/python3.12/site-packages/pillow.libs/libwebpdemux-747f2b49.so.2.0.17 b/.venv/lib/python3.12/site-packages/pillow.libs/libwebpdemux-747f2b49.so.2.0.17 new file mode 100644 index 0000000000000000000000000000000000000000..7a4f0eb0adbcbf06c2da4bbcaeb55e47199c4792 Binary files /dev/null and b/.venv/lib/python3.12/site-packages/pillow.libs/libwebpdemux-747f2b49.so.2.0.17 differ diff --git a/.venv/lib/python3.12/site-packages/torchvision/__init__.py b/.venv/lib/python3.12/site-packages/torchvision/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5d06156c25f1dfd34e9f01529e5a6b4bbeda7b42 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/torchvision/__init__.py @@ -0,0 +1,105 @@ +import os +import warnings +from modulefinder import Module + +import torch + +# Don't re-order these, we need to load the _C extension (done when importing +# .extensions) before entering _meta_registrations. +from .extension import _HAS_OPS # usort:skip +from torchvision import _meta_registrations, datasets, io, models, ops, transforms, utils # usort:skip + +try: + from .version import __version__ # noqa: F401 +except ImportError: + pass + + +# Check if torchvision is being imported within the root folder +if not _HAS_OPS and os.path.dirname(os.path.realpath(__file__)) == os.path.join( + os.path.realpath(os.getcwd()), "torchvision" +): + message = ( + "You are importing torchvision within its own root folder ({}). " + "This is not expected to work and may give errors. Please exit the " + "torchvision project source and relaunch your python interpreter." + ) + warnings.warn(message.format(os.getcwd())) + +_image_backend = "PIL" + +_video_backend = "pyav" + + +def set_image_backend(backend): + """ + Specifies the package used to load images. + + Args: + backend (string): Name of the image backend. one of {'PIL', 'accimage'}. + The :mod:`accimage` package uses the Intel IPP library. It is + generally faster than PIL, but does not support as many operations. + """ + global _image_backend + if backend not in ["PIL", "accimage"]: + raise ValueError(f"Invalid backend '{backend}'. Options are 'PIL' and 'accimage'") + _image_backend = backend + + +def get_image_backend(): + """ + Gets the name of the package used to load images + """ + return _image_backend + + +def set_video_backend(backend): + """ + Specifies the package used to decode videos. + + Args: + backend (string): Name of the video backend. one of {'pyav', 'video_reader'}. + The :mod:`pyav` package uses the 3rd party PyAv library. It is a Pythonic + binding for the FFmpeg libraries. + The :mod:`video_reader` package includes a native C++ implementation on + top of FFMPEG libraries, and a python API of TorchScript custom operator. + It generally decodes faster than :mod:`pyav`, but is perhaps less robust. + + .. note:: + Building with FFMPEG is disabled by default in the latest `main`. If you want to use the 'video_reader' + backend, please compile torchvision from source. + """ + global _video_backend + if backend not in ["pyav", "video_reader", "cuda"]: + raise ValueError("Invalid video backend '%s'. Options are 'pyav', 'video_reader' and 'cuda'" % backend) + if backend == "video_reader" and not io._HAS_CPU_VIDEO_DECODER: + # TODO: better messages + message = "video_reader video backend is not available. Please compile torchvision from source and try again" + raise RuntimeError(message) + elif backend == "cuda" and not io._HAS_GPU_VIDEO_DECODER: + # TODO: better messages + message = "cuda video backend is not available." + raise RuntimeError(message) + else: + _video_backend = backend + + +def get_video_backend(): + """ + Returns the currently active video backend used to decode videos. + + Returns: + str: Name of the video backend. one of {'pyav', 'video_reader'}. + """ + + return _video_backend + + +def _is_tracing(): + return torch._C._get_tracing_state() + + +def disable_beta_transforms_warning(): + # Noop, only exists to avoid breaking existing code. + # See https://github.com/pytorch/vision/issues/7896 + pass diff --git a/.venv/lib/python3.12/site-packages/torchvision/_internally_replaced_utils.py b/.venv/lib/python3.12/site-packages/torchvision/_internally_replaced_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e0fa72489f1ac8fba771fc7bc20fc80424a71d85 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/torchvision/_internally_replaced_utils.py @@ -0,0 +1,51 @@ +import importlib.machinery +import os + +from torch.hub import _get_torch_home + + +_HOME = os.path.join(_get_torch_home(), "datasets", "vision") +_USE_SHARDED_DATASETS = False +IN_FBCODE = False + + +def _download_file_from_remote_location(fpath: str, url: str) -> None: + pass + + +def _is_remote_location_available() -> bool: + return False + + +try: + from torch.hub import load_state_dict_from_url # noqa: 401 +except ImportError: + from torch.utils.model_zoo import load_url as load_state_dict_from_url # noqa: 401 + + +def _get_extension_path(lib_name): + + lib_dir = os.path.dirname(__file__) + if os.name == "nt": + # Register the main torchvision library location on the default DLL path + import ctypes + + kernel32 = ctypes.WinDLL("kernel32.dll", use_last_error=True) + with_load_library_flags = hasattr(kernel32, "AddDllDirectory") + prev_error_mode = kernel32.SetErrorMode(0x0001) + + if with_load_library_flags: + kernel32.AddDllDirectory.restype = ctypes.c_void_p + + os.add_dll_directory(lib_dir) + + kernel32.SetErrorMode(prev_error_mode) + + loader_details = (importlib.machinery.ExtensionFileLoader, importlib.machinery.EXTENSION_SUFFIXES) + + extfinder = importlib.machinery.FileFinder(lib_dir, loader_details) + ext_specs = extfinder.find_spec(lib_name) + if ext_specs is None: + raise ImportError + + return ext_specs.origin diff --git a/.venv/lib/python3.12/site-packages/torchvision/_meta_registrations.py b/.venv/lib/python3.12/site-packages/torchvision/_meta_registrations.py new file mode 100644 index 0000000000000000000000000000000000000000..f75bfb77a7f25a1842509de595f109f232994574 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/torchvision/_meta_registrations.py @@ -0,0 +1,225 @@ +import functools + +import torch +import torch._custom_ops +import torch.library + +# Ensure that torch.ops.torchvision is visible +import torchvision.extension # noqa: F401 + + +@functools.lru_cache(None) +def get_meta_lib(): + return torch.library.Library("torchvision", "IMPL", "Meta") + + +def register_meta(op_name, overload_name="default"): + def wrapper(fn): + if torchvision.extension._has_ops(): + get_meta_lib().impl(getattr(getattr(torch.ops.torchvision, op_name), overload_name), fn) + return fn + + return wrapper + + +@register_meta("roi_align") +def meta_roi_align(input, rois, spatial_scale, pooled_height, pooled_width, sampling_ratio, aligned): + torch._check(rois.size(1) == 5, lambda: "rois must have shape as Tensor[K, 5]") + torch._check( + input.dtype == rois.dtype, + lambda: ( + "Expected tensor for input to have the same type as tensor for rois; " + f"but type {input.dtype} does not equal {rois.dtype}" + ), + ) + num_rois = rois.size(0) + channels = input.size(1) + return input.new_empty((num_rois, channels, pooled_height, pooled_width)) + + +@register_meta("_roi_align_backward") +def meta_roi_align_backward( + grad, rois, spatial_scale, pooled_height, pooled_width, batch_size, channels, height, width, sampling_ratio, aligned +): + torch._check( + grad.dtype == rois.dtype, + lambda: ( + "Expected tensor for grad to have the same type as tensor for rois; " + f"but type {grad.dtype} does not equal {rois.dtype}" + ), + ) + return grad.new_empty((batch_size, channels, height, width)) + + +@register_meta("ps_roi_align") +def meta_ps_roi_align(input, rois, spatial_scale, pooled_height, pooled_width, sampling_ratio): + torch._check(rois.size(1) == 5, lambda: "rois must have shape as Tensor[K, 5]") + torch._check( + input.dtype == rois.dtype, + lambda: ( + "Expected tensor for input to have the same type as tensor for rois; " + f"but type {input.dtype} does not equal {rois.dtype}" + ), + ) + channels = input.size(1) + torch._check( + channels % (pooled_height * pooled_width) == 0, + "input channels must be a multiple of pooling height * pooling width", + ) + + num_rois = rois.size(0) + out_size = (num_rois, channels // (pooled_height * pooled_width), pooled_height, pooled_width) + return input.new_empty(out_size), torch.empty(out_size, dtype=torch.int32, device="meta") + + +@register_meta("_ps_roi_align_backward") +def meta_ps_roi_align_backward( + grad, + rois, + channel_mapping, + spatial_scale, + pooled_height, + pooled_width, + sampling_ratio, + batch_size, + channels, + height, + width, +): + torch._check( + grad.dtype == rois.dtype, + lambda: ( + "Expected tensor for grad to have the same type as tensor for rois; " + f"but type {grad.dtype} does not equal {rois.dtype}" + ), + ) + return grad.new_empty((batch_size, channels, height, width)) + + +@register_meta("roi_pool") +def meta_roi_pool(input, rois, spatial_scale, pooled_height, pooled_width): + torch._check(rois.size(1) == 5, lambda: "rois must have shape as Tensor[K, 5]") + torch._check( + input.dtype == rois.dtype, + lambda: ( + "Expected tensor for input to have the same type as tensor for rois; " + f"but type {input.dtype} does not equal {rois.dtype}" + ), + ) + num_rois = rois.size(0) + channels = input.size(1) + out_size = (num_rois, channels, pooled_height, pooled_width) + return input.new_empty(out_size), torch.empty(out_size, device="meta", dtype=torch.int32) + + +@register_meta("_roi_pool_backward") +def meta_roi_pool_backward( + grad, rois, argmax, spatial_scale, pooled_height, pooled_width, batch_size, channels, height, width +): + torch._check( + grad.dtype == rois.dtype, + lambda: ( + "Expected tensor for grad to have the same type as tensor for rois; " + f"but type {grad.dtype} does not equal {rois.dtype}" + ), + ) + return grad.new_empty((batch_size, channels, height, width)) + + +@register_meta("ps_roi_pool") +def meta_ps_roi_pool(input, rois, spatial_scale, pooled_height, pooled_width): + torch._check(rois.size(1) == 5, lambda: "rois must have shape as Tensor[K, 5]") + torch._check( + input.dtype == rois.dtype, + lambda: ( + "Expected tensor for input to have the same type as tensor for rois; " + f"but type {input.dtype} does not equal {rois.dtype}" + ), + ) + channels = input.size(1) + torch._check( + channels % (pooled_height * pooled_width) == 0, + "input channels must be a multiple of pooling height * pooling width", + ) + num_rois = rois.size(0) + out_size = (num_rois, channels // (pooled_height * pooled_width), pooled_height, pooled_width) + return input.new_empty(out_size), torch.empty(out_size, device="meta", dtype=torch.int32) + + +@register_meta("_ps_roi_pool_backward") +def meta_ps_roi_pool_backward( + grad, rois, channel_mapping, spatial_scale, pooled_height, pooled_width, batch_size, channels, height, width +): + torch._check( + grad.dtype == rois.dtype, + lambda: ( + "Expected tensor for grad to have the same type as tensor for rois; " + f"but type {grad.dtype} does not equal {rois.dtype}" + ), + ) + return grad.new_empty((batch_size, channels, height, width)) + + +@torch.library.register_fake("torchvision::nms") +def meta_nms(dets, scores, iou_threshold): + torch._check(dets.dim() == 2, lambda: f"boxes should be a 2d tensor, got {dets.dim()}D") + torch._check(dets.size(1) == 4, lambda: f"boxes should have 4 elements in dimension 1, got {dets.size(1)}") + torch._check(scores.dim() == 1, lambda: f"scores should be a 1d tensor, got {scores.dim()}") + torch._check( + dets.size(0) == scores.size(0), + lambda: f"boxes and scores should have same number of elements in dimension 0, got {dets.size(0)} and {scores.size(0)}", + ) + ctx = torch._custom_ops.get_ctx() + num_to_keep = ctx.create_unbacked_symint() + return dets.new_empty(num_to_keep, dtype=torch.long) + + +@register_meta("deform_conv2d") +def meta_deform_conv2d( + input, + weight, + offset, + mask, + bias, + stride_h, + stride_w, + pad_h, + pad_w, + dil_h, + dil_w, + n_weight_grps, + n_offset_grps, + use_mask, +): + + out_height, out_width = offset.shape[-2:] + out_channels = weight.shape[0] + batch_size = input.shape[0] + return input.new_empty((batch_size, out_channels, out_height, out_width)) + + +@register_meta("_deform_conv2d_backward") +def meta_deform_conv2d_backward( + grad, + input, + weight, + offset, + mask, + bias, + stride_h, + stride_w, + pad_h, + pad_w, + dilation_h, + dilation_w, + groups, + offset_groups, + use_mask, +): + + grad_input = input.new_empty(input.shape) + grad_weight = weight.new_empty(weight.shape) + grad_offset = offset.new_empty(offset.shape) + grad_mask = mask.new_empty(mask.shape) + grad_bias = bias.new_empty(bias.shape) + return grad_input, grad_weight, grad_offset, grad_mask, grad_bias diff --git a/.venv/lib/python3.12/site-packages/torchvision/extension.py b/.venv/lib/python3.12/site-packages/torchvision/extension.py new file mode 100644 index 0000000000000000000000000000000000000000..67801056e88b44d40bc2d382d62c389bf4ef039e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/torchvision/extension.py @@ -0,0 +1,92 @@ +import os +import sys + +import torch + +from ._internally_replaced_utils import _get_extension_path + + +_HAS_OPS = False + + +def _has_ops(): + return False + + +try: + # On Windows Python-3.8.x has `os.add_dll_directory` call, + # which is called to configure dll search path. + # To find cuda related dlls we need to make sure the + # conda environment/bin path is configured Please take a look: + # https://stackoverflow.com/questions/59330863/cant-import-dll-module-in-python + # Please note: if some path can't be added using add_dll_directory we simply ignore this path + if os.name == "nt" and sys.version_info < (3, 9): + env_path = os.environ["PATH"] + path_arr = env_path.split(";") + for path in path_arr: + if os.path.exists(path): + try: + os.add_dll_directory(path) # type: ignore[attr-defined] + except Exception: + pass + + lib_path = _get_extension_path("_C") + torch.ops.load_library(lib_path) + _HAS_OPS = True + + def _has_ops(): # noqa: F811 + return True + +except (ImportError, OSError): + pass + + +def _assert_has_ops(): + if not _has_ops(): + raise RuntimeError( + "Couldn't load custom C++ ops. This can happen if your PyTorch and " + "torchvision versions are incompatible, or if you had errors while compiling " + "torchvision from source. For further information on the compatible versions, check " + "https://github.com/pytorch/vision#installation for the compatibility matrix. " + "Please check your PyTorch version with torch.__version__ and your torchvision " + "version with torchvision.__version__ and verify if they are compatible, and if not " + "please reinstall torchvision so that it matches your PyTorch install." + ) + + +def _check_cuda_version(): + """ + Make sure that CUDA versions match between the pytorch install and torchvision install + """ + if not _HAS_OPS: + return -1 + from torch.version import cuda as torch_version_cuda + + _version = torch.ops.torchvision._cuda_version() + if _version != -1 and torch_version_cuda is not None: + tv_version = str(_version) + if int(tv_version) < 10000: + tv_major = int(tv_version[0]) + tv_minor = int(tv_version[2]) + else: + tv_major = int(tv_version[0:2]) + tv_minor = int(tv_version[3]) + t_version = torch_version_cuda.split(".") + t_major = int(t_version[0]) + t_minor = int(t_version[1]) + if t_major != tv_major: + raise RuntimeError( + "Detected that PyTorch and torchvision were compiled with different CUDA major versions. " + f"PyTorch has CUDA Version={t_major}.{t_minor} and torchvision has " + f"CUDA Version={tv_major}.{tv_minor}. " + "Please reinstall the torchvision that matches your PyTorch install." + ) + return _version + + +def _load_library(lib_name): + lib_path = _get_extension_path(lib_name) + torch.ops.load_library(lib_path) + + +_check_cuda_version() diff --git a/.venv/lib/python3.12/site-packages/torchvision/utils.py b/.venv/lib/python3.12/site-packages/torchvision/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0d819ef8330024daec22ad07321ce983ba7edd8c --- /dev/null +++ b/.venv/lib/python3.12/site-packages/torchvision/utils.py @@ -0,0 +1,799 @@ +import collections +import math +import pathlib +import warnings +from itertools import repeat +from types import FunctionType +from typing import Any, BinaryIO, Optional, Union + +import numpy as np +import torch +from PIL import __version__ as PILLOW_VERSION_STRING, Image, ImageColor, ImageDraw, ImageFont + + +__all__ = [ + "_Image_fromarray", + "make_grid", + "save_image", + "draw_bounding_boxes", + "draw_segmentation_masks", + "draw_keypoints", + "flow_to_image", +] + + +@torch.no_grad() +def make_grid( + tensor: Union[torch.Tensor, list[torch.Tensor]], + nrow: int = 8, + padding: int = 2, + normalize: bool = False, + value_range: Optional[tuple[int, int]] = None, + scale_each: bool = False, + pad_value: float = 0.0, +) -> torch.Tensor: + """ + Make a grid of images. + + Args: + tensor (Tensor or list): 4D mini-batch Tensor of shape (B x C x H x W) + or a list of images all of the same size. + nrow (int, optional): Number of images displayed in each row of the grid. + The final grid size is ``(B / nrow, nrow)``. Default: ``8``. + padding (int, optional): amount of padding. Default: ``2``. + normalize (bool, optional): If True, shift the image to the range (0, 1), + by the min and max values specified by ``value_range``. Default: ``False``. + value_range (tuple, optional): tuple (min, max) where min and max are numbers, + then these numbers are used to normalize the image. By default, min and max + are computed from the tensor. + scale_each (bool, optional): If ``True``, scale each image in the batch of + images separately rather than the (min, max) over all images. Default: ``False``. + pad_value (float, optional): Value for the padded pixels. Default: ``0``. + + Returns: + grid (Tensor): the tensor containing grid of images. + """ + if not torch.jit.is_scripting() and not torch.jit.is_tracing(): + _log_api_usage_once(make_grid) + if not torch.is_tensor(tensor): + if isinstance(tensor, list): + for t in tensor: + if not torch.is_tensor(t): + raise TypeError(f"tensor or list of tensors expected, got a list containing {type(t)}") + else: + raise TypeError(f"tensor or list of tensors expected, got {type(tensor)}") + + # if list of tensors, convert to a 4D mini-batch Tensor + if isinstance(tensor, list): + tensor = torch.stack(tensor, dim=0) + + if tensor.dim() == 2: # single image H x W + tensor = tensor.unsqueeze(0) + if tensor.dim() == 3: # single image + if tensor.size(0) == 1: # if single-channel, convert to 3-channel + tensor = torch.cat((tensor, tensor, tensor), 0) + tensor = tensor.unsqueeze(0) + + if tensor.dim() == 4 and tensor.size(1) == 1: # single-channel images + tensor = torch.cat((tensor, tensor, tensor), 1) + + if normalize is True: + tensor = tensor.clone() # avoid modifying tensor in-place + if value_range is not None and not isinstance(value_range, tuple): + raise TypeError("value_range has to be a tuple (min, max) if specified. min and max are numbers") + + def norm_ip(img, low, high): + img.clamp_(min=low, max=high) + img.sub_(low).div_(max(high - low, 1e-5)) + + def norm_range(t, value_range): + if value_range is not None: + norm_ip(t, value_range[0], value_range[1]) + else: + norm_ip(t, float(t.min()), float(t.max())) + + if scale_each is True: + for t in tensor: # loop over mini-batch dimension + norm_range(t, value_range) + else: + norm_range(tensor, value_range) + + if not isinstance(tensor, torch.Tensor): + raise TypeError("tensor should be of type torch.Tensor") + if tensor.size(0) == 1: + return tensor.squeeze(0) + + # make the mini-batch of images into a grid + nmaps = tensor.size(0) + xmaps = min(nrow, nmaps) + ymaps = int(math.ceil(float(nmaps) / xmaps)) + height, width = int(tensor.size(2) + padding), int(tensor.size(3) + padding) + num_channels = tensor.size(1) + grid = tensor.new_full((num_channels, height * ymaps + padding, width * xmaps + padding), pad_value) + k = 0 + for y in range(ymaps): + for x in range(xmaps): + if k >= nmaps: + break + # Tensor.copy_() is a valid method but seems to be missing from the stubs + # https://pytorch.org/docs/stable/tensors.html#torch.Tensor.copy_ + grid.narrow(1, y * height + padding, height - padding).narrow( # type: ignore[attr-defined] + 2, x * width + padding, width - padding + ).copy_(tensor[k]) + k = k + 1 + return grid + + +class _ImageDrawTV(ImageDraw.ImageDraw): + """ + A wrapper around PIL.ImageDraw to add functionalities for drawing rotated bounding boxes. + """ + + def oriented_rectangle(self, xy, fill=None, outline=None, width=1): + self.dashed_line(((xy[0], xy[1]), (xy[2], xy[3])), width=width, fill=outline) + for i in range(2, len(xy), 2): + self.line( + ((xy[i], xy[i + 1]), (xy[(i + 2) % len(xy)], xy[(i + 3) % len(xy)])), + width=width, + fill=outline, + ) + self.polygon(xy, fill=fill, outline=None, width=0) + + def dashed_line(self, xy, fill=None, width=0, joint=None, dash_length=5, space_length=5): + # Calculate the total length of the line + total_length = 0 + for i in range(1, len(xy)): + x1, y1 = xy[i - 1] + x2, y2 = xy[i] + total_length += ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 + # Initialize the current position and the current dash + current_position = 0 + current_dash = True + # Iterate over the coordinates of the line + for i in range(1, len(xy)): + x1, y1 = xy[i - 1] + x2, y2 = xy[i] + # Calculate the length of this segment + segment_length = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5 + # While there are still dashes to draw on this segment + while segment_length > 0: + # Calculate the length of this dash + dash_length_to_draw = min(segment_length, dash_length if current_dash else space_length) + # Calculate the end point of this dash + dx = x2 - x1 + dy = y2 - y1 + angle = math.atan2(dy, dx) + end_x = x1 + math.cos(angle) * dash_length_to_draw + end_y = y1 + math.sin(angle) * dash_length_to_draw + # If this is a dash, draw it + if current_dash: + self.line([(x1, y1), (end_x, end_y)], fill, width, joint) + # Update the current position and the current dash + current_position += dash_length_to_draw + segment_length -= dash_length_to_draw + x1, y1 = end_x, end_y + current_dash = not current_dash + + +def _Image_fromarray( + obj: np.ndarray, + mode: str, +) -> Image.Image: + """ + A wrapper around PIL.Image.fromarray to mitigate the deprecation of the + mode paramter. See: + https://pillow.readthedocs.io/en/stable/releasenotes/11.3.0.html#image-fromarray-mode-parameter + """ + + # This may throw if the version string is from an install that comes from a + # non-stable or development version. We'll fall back to the old behavior in + # such cases. + try: + PILLOW_VERSION = tuple(int(x) for x in PILLOW_VERSION_STRING.split(".")) + except Exception: + PILLOW_VERSION = None + + if PILLOW_VERSION is not None and PILLOW_VERSION >= (11, 3): + # The actual PR that implements the deprecation has more context for why + # it was done, and also points out some problems: + # + # https://github.com/python-pillow/Pillow/pull/9018 + # + # Our use case falls into those problems. We actually rely on the old + # behavior of Image.fromarray(): + # + # new behavior: PIL will infer the image mode from the data passed + # in. That is, the type and shape determines the mode. + # + # old behiavor: The mode will change how PIL reads the image, + # regardless of the data. That is, it will make the + # data work with the mode. + # + # Our uses of Image.fromarray() are effectively a "turn into PIL image + # AND convert the kind" operation. In particular, in + # functional.to_pil_image() and transforms.ToPILImage. + # + # However, Image.frombuffer() still performs this conversion. The code + # below is lifted from the new implementation of Image.fromarray(). We + # omit the code that infers the mode, and use the code that figures out + # from the data passed in (obj) what the correct parameters are to + # Image.frombuffer(). + # + # Note that the alternate solution below does not work: + # + # img = Image.fromarray(obj) + # img = img.convert(mode) + # + # The resulting image has very different actual pixel values than before. + # + # TODO: Issue #9151. Pillow has an open PR to restore the functionality + # we rely on: + # + # https://github.com/python-pillow/Pillow/pull/9063 + # + # When that is part of a release, we can revisit this hack below. + arr = obj.__array_interface__ + shape = arr["shape"] + ndim = len(shape) + size = 1 if ndim == 1 else shape[1], shape[0] + + strides = arr.get("strides", None) + contiguous_obj: Union[np.ndarray, bytes] = obj + if strides is not None: + # We require that the data is contiguous; if it is not, we need to + # convert it into a contiguous format. + if hasattr(obj, "tobytes"): + contiguous_obj = obj.tobytes() + elif hasattr(obj, "tostring"): + contiguous_obj = obj.tostring() + else: + raise ValueError("Unable to convert obj into contiguous format") + + return Image.frombuffer(mode, size, contiguous_obj, "raw", mode, 0, 1) + else: + return Image.fromarray(obj, mode) + + +@torch.no_grad() +def save_image( + tensor: Union[torch.Tensor, list[torch.Tensor]], + fp: Union[str, pathlib.Path, BinaryIO], + format: Optional[str] = None, + **kwargs, +) -> None: + """ + Save a given Tensor into an image file. + + Args: + tensor (Tensor or list): Image to be saved. If given a mini-batch tensor, + saves the tensor as a grid of images by calling ``make_grid``. + fp (string or file object): A filename or a file object + format(Optional): If omitted, the format to use is determined from the filename extension. + If a file object was used instead of a filename, this parameter should always be used. + **kwargs: Other arguments are documented in ``make_grid``. + """ + + if not torch.jit.is_scripting() and not torch.jit.is_tracing(): + _log_api_usage_once(save_image) + grid = make_grid(tensor, **kwargs) + # Add 0.5 after unnormalizing to [0, 255] to round to the nearest integer + ndarr = grid.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to("cpu", torch.uint8).numpy() + im = Image.fromarray(ndarr) + im.save(fp, format=format) + + +@torch.no_grad() +def draw_bounding_boxes( + image: torch.Tensor, + boxes: torch.Tensor, + labels: Optional[list[str]] = None, + colors: Optional[Union[list[Union[str, tuple[int, int, int]]], str, tuple[int, int, int]]] = None, + fill: Optional[bool] = False, + width: int = 1, + font: Optional[str] = None, + font_size: Optional[int] = None, + label_colors: Optional[Union[list[Union[str, tuple[int, int, int]]], str, tuple[int, int, int]]] = None, + fill_labels: bool = False, +) -> torch.Tensor: + """ + Draws bounding boxes on given RGB image. + The image values should be uint8 in [0, 255] or float in [0, 1]. + If fill is True, Resulting Tensor should be saved as PNG image. + + Args: + image (Tensor): Tensor of shape (C, H, W) and dtype uint8 or float. + boxes (Tensor): Tensor of size (N, 4) or (N, 8) containing bounding boxes. + For (N, 4), the format is (xmin, ymin, xmax, ymax) and the boxes are absolute coordinates with respect to the image. + In other words: `0 <= xmin < xmax < W` and `0 <= ymin < ymax < H`. + For (N, 8), the format is (x1, y1, x2, y2, x3, y3, x4, y4) and the boxes are absolute coordinates with respect to the underlying + object, so no need to verify the latter inequalities. + labels (List[str]): List containing the labels of bounding boxes. + colors (color or list of colors, optional): List containing the colors + of the boxes or single color for all boxes. The color can be represented as + PIL strings e.g. "red" or "#FF00FF", or as RGB tuples e.g. ``(240, 10, 157)``. + By default, random colors are generated for boxes. + fill (bool): If `True` fills the bounding box with specified color. + width (int): Width of bounding box. + font (str): A filename containing a TrueType font. If the file is not found in this filename, the loader may + also search in other directories, such as the `fonts/` directory on Windows or `/Library/Fonts/`, + `/System/Library/Fonts/` and `~/Library/Fonts/` on macOS. + font_size (int): The requested font size in points. + label_colors (color or list of colors, optional): Colors for the label text. See the description of the + `colors` argument for details. Defaults to the same colors used for the boxes, or to black if ``fill_labels`` is True. + fill_labels (bool): If `True` fills the label background with specified box color (from the ``colors`` parameter). Default: False. + + Returns: + img (Tensor[C, H, W]): Image Tensor of dtype uint8 with bounding boxes plotted. + + """ + import torchvision.transforms.v2.functional as F # noqa + + if not torch.jit.is_scripting() and not torch.jit.is_tracing(): + _log_api_usage_once(draw_bounding_boxes) + if not isinstance(image, torch.Tensor): + raise TypeError(f"Tensor expected, got {type(image)}") + elif not (image.dtype == torch.uint8 or image.is_floating_point()): + raise ValueError(f"The image dtype must be uint8 or float, got {image.dtype}") + elif image.dim() != 3: + raise ValueError("Pass individual images, not batches") + elif image.size(0) not in {1, 3}: + raise ValueError("Only grayscale and RGB images are supported") + elif boxes.shape[-1] == 4 and ((boxes[:, 0] > boxes[:, 2]).any() or (boxes[:, 1] > boxes[:, 3]).any()): + raise ValueError( + "Boxes need to be in (xmin, ymin, xmax, ymax) format. Use torchvision.ops.box_convert to convert them" + ) + + num_boxes = boxes.shape[0] + + if num_boxes == 0: + warnings.warn("boxes doesn't contain any box. No box was drawn") + return image + + if labels is None: + labels: Union[list[str], list[None]] = [None] * num_boxes # type: ignore[no-redef] + elif len(labels) != num_boxes: + raise ValueError( + f"Number of boxes ({num_boxes}) and labels ({len(labels)}) mismatch. Please specify labels for each box." + ) + + colors = _parse_colors(colors, num_objects=num_boxes) + if label_colors or fill_labels: + label_colors = _parse_colors(label_colors if label_colors else "black", num_objects=num_boxes) # type: ignore[assignment] + else: + label_colors = colors.copy() # type: ignore[assignment] + + if font is None: + if font_size is not None: + warnings.warn("Argument 'font_size' will be ignored since 'font' is not set.") + txt_font = ImageFont.load_default() + else: + txt_font = ImageFont.truetype(font=font, size=font_size or 10) + + # Handle Grayscale images + if image.size(0) == 1: + image = torch.tile(image, (3, 1, 1)) + + original_dtype = image.dtype + if original_dtype.is_floating_point: + image = F.to_dtype(image, dtype=torch.uint8, scale=True) + + img_to_draw = F.to_pil_image(image) + img_boxes = boxes.to(torch.int64).tolist() + + if fill: + draw = _ImageDrawTV(img_to_draw, "RGBA") + else: + draw = _ImageDrawTV(img_to_draw) + + for bbox, color, label, label_color in zip(img_boxes, colors, labels, label_colors): # type: ignore[arg-type] + draw_method = draw.oriented_rectangle if len(bbox) > 4 else draw.rectangle + fill_color = color + (100,) if fill else None + draw_method(bbox, width=width, outline=color, fill=fill_color) + + if label is not None: + box_margin = 1 + margin = width + box_margin + if fill_labels: + left, top, right, bottom = draw.textbbox((bbox[0] + margin, bbox[1] + margin), label, font=txt_font) + draw.rectangle( + (left - box_margin, top - box_margin, right + box_margin, bottom + box_margin), fill=color + ) + draw.text((bbox[0] + margin, bbox[1] + margin), label, fill=label_color, font=txt_font) # type: ignore[arg-type] + + out = F.pil_to_tensor(img_to_draw) + if original_dtype.is_floating_point: + out = F.to_dtype(out, dtype=original_dtype, scale=True) + return out + + +@torch.no_grad() +def draw_segmentation_masks( + image: torch.Tensor, + masks: torch.Tensor, + alpha: float = 0.8, + colors: Optional[Union[list[Union[str, tuple[int, int, int]]], str, tuple[int, int, int]]] = None, +) -> torch.Tensor: + """ + Draws segmentation masks on given RGB image. + The image values should be uint8 in [0, 255] or float in [0, 1]. + + Args: + image (Tensor): Tensor of shape (3, H, W) and dtype uint8 or float. + masks (Tensor): Tensor of shape (num_masks, H, W) or (H, W) and dtype bool. + alpha (float): Float number between 0 and 1 denoting the transparency of the masks. + 0 means full transparency, 1 means no transparency. + colors (color or list of colors, optional): List containing the colors + of the masks or single color for all masks. The color can be represented as + PIL strings e.g. "red" or "#FF00FF", or as RGB tuples e.g. ``(240, 10, 157)``. + By default, random colors are generated for each mask. + + Returns: + img (Tensor[C, H, W]): Image Tensor, with segmentation masks drawn on top. + """ + + if not torch.jit.is_scripting() and not torch.jit.is_tracing(): + _log_api_usage_once(draw_segmentation_masks) + if not isinstance(image, torch.Tensor): + raise TypeError(f"The image must be a tensor, got {type(image)}") + elif not (image.dtype == torch.uint8 or image.is_floating_point()): + raise ValueError(f"The image dtype must be uint8 or float, got {image.dtype}") + elif image.dim() != 3: + raise ValueError("Pass individual images, not batches") + elif image.size()[0] != 3: + raise ValueError("Pass an RGB image. Other Image formats are not supported") + if masks.ndim == 2: + masks = masks[None, :, :] + if masks.ndim != 3: + raise ValueError("masks must be of shape (H, W) or (batch_size, H, W)") + if masks.dtype != torch.bool: + raise ValueError(f"The masks must be of dtype bool. Got {masks.dtype}") + if masks.shape[-2:] != image.shape[-2:]: + raise ValueError("The image and the masks must have the same height and width") + + num_masks = masks.size()[0] + overlapping_masks = masks.sum(dim=0) > 1 + + if num_masks == 0: + warnings.warn("masks doesn't contain any mask. No mask was drawn") + return image + + original_dtype = image.dtype + colors = [ + torch.tensor(color, dtype=original_dtype, device=image.device) + for color in _parse_colors(colors, num_objects=num_masks, dtype=original_dtype) + ] + + img_to_draw = image.detach().clone() + # TODO: There might be a way to vectorize this + for mask, color in zip(masks, colors): + img_to_draw[:, mask] = color[:, None] + + img_to_draw[:, overlapping_masks] = 0 + + out = image * (1 - alpha) + img_to_draw * alpha + # Note: at this point, out is a float tensor in [0, 1] or [0, 255] depending on original_dtype + return out.to(original_dtype) + + +@torch.no_grad() +def draw_keypoints( + image: torch.Tensor, + keypoints: torch.Tensor, + connectivity: Optional[list[tuple[int, int]]] = None, + colors: Optional[Union[str, tuple[int, int, int]]] = None, + radius: int = 2, + width: int = 3, + visibility: Optional[torch.Tensor] = None, +) -> torch.Tensor: + """ + Draws Keypoints on given RGB image. + The image values should be uint8 in [0, 255] or float in [0, 1]. + Keypoints can be drawn for multiple instances at a time. + + This method allows that keypoints and their connectivity are drawn based on the visibility of this keypoint. + + Args: + image (Tensor): Tensor of shape (3, H, W) and dtype uint8 or float. + keypoints (Tensor): Tensor of shape (num_instances, K, 2) the K keypoint locations for each of the N instances, + in the format [x, y]. + connectivity (List[Tuple[int, int]]]): A List of tuple where each tuple contains a pair of keypoints + to be connected. + If at least one of the two connected keypoints has a ``visibility`` of False, + this specific connection is not drawn. + Exclusions due to invisibility are computed per-instance. + colors (str, Tuple): The color can be represented as + PIL strings e.g. "red" or "#FF00FF", or as RGB tuples e.g. ``(240, 10, 157)``. + radius (int): Integer denoting radius of keypoint. + width (int): Integer denoting width of line connecting keypoints. + visibility (Tensor): Tensor of shape (num_instances, K) specifying the visibility of the K + keypoints for each of the N instances. + True means that the respective keypoint is visible and should be drawn. + False means invisible, so neither the point nor possible connections containing it are drawn. + The input tensor will be cast to bool. + Default ``None`` means that all the keypoints are visible. + For more details, see :ref:`draw_keypoints_with_visibility`. + + Returns: + img (Tensor[C, H, W]): Image Tensor with keypoints drawn. + """ + + if not torch.jit.is_scripting() and not torch.jit.is_tracing(): + _log_api_usage_once(draw_keypoints) + # validate image + if not isinstance(image, torch.Tensor): + raise TypeError(f"The image must be a tensor, got {type(image)}") + elif not (image.dtype == torch.uint8 or image.is_floating_point()): + raise ValueError(f"The image dtype must be uint8 or float, got {image.dtype}") + elif image.dim() != 3: + raise ValueError("Pass individual images, not batches") + elif image.size()[0] != 3: + raise ValueError("Pass an RGB image. Other Image formats are not supported") + + # validate keypoints + if keypoints.ndim != 3: + raise ValueError("keypoints must be of shape (num_instances, K, 2)") + + # validate visibility + if visibility is None: # set default + visibility = torch.ones(keypoints.shape[:-1], dtype=torch.bool) + if visibility.ndim == 3: + # If visibility was passed as pred.split([2, 1], dim=-1), it will be of shape (num_instances, K, 1). + # We make sure it is of shape (num_instances, K). This isn't documented, we're just being nice. + visibility = visibility.squeeze(-1) + if visibility.ndim != 2: + raise ValueError(f"visibility must be of shape (num_instances, K). Got ndim={visibility.ndim}") + if visibility.shape != keypoints.shape[:-1]: + raise ValueError( + "keypoints and visibility must have the same dimensionality for num_instances and K. " + f"Got {visibility.shape = } and {keypoints.shape = }" + ) + + original_dtype = image.dtype + if original_dtype.is_floating_point: + from torchvision.transforms.v2.functional import to_dtype # noqa + + image = to_dtype(image, dtype=torch.uint8, scale=True) + + ndarr = image.permute(1, 2, 0).cpu().numpy() + img_to_draw = Image.fromarray(ndarr) + draw = ImageDraw.Draw(img_to_draw) + img_kpts = keypoints.to(torch.int64).tolist() + img_vis = visibility.cpu().bool().tolist() + + for kpt_inst, vis_inst in zip(img_kpts, img_vis): + for kpt_coord, kp_vis in zip(kpt_inst, vis_inst): + if not kp_vis: + continue + x1 = kpt_coord[0] - radius + x2 = kpt_coord[0] + radius + y1 = kpt_coord[1] - radius + y2 = kpt_coord[1] + radius + draw.ellipse([x1, y1, x2, y2], fill=colors, outline=None, width=0) + + if connectivity: + for connection in connectivity: + if (not vis_inst[connection[0]]) or (not vis_inst[connection[1]]): + continue + start_pt_x = kpt_inst[connection[0]][0] + start_pt_y = kpt_inst[connection[0]][1] + + end_pt_x = kpt_inst[connection[1]][0] + end_pt_y = kpt_inst[connection[1]][1] + + draw.line( + ((start_pt_x, start_pt_y), (end_pt_x, end_pt_y)), + width=width, + ) + + out = torch.from_numpy(np.array(img_to_draw)).permute(2, 0, 1) + if original_dtype.is_floating_point: + out = to_dtype(out, dtype=original_dtype, scale=True) + return out + + +# Flow visualization code adapted from https://github.com/tomrunia/OpticalFlow_Visualization +@torch.no_grad() +def flow_to_image(flow: torch.Tensor) -> torch.Tensor: + """ + Converts a flow to an RGB image. + + Args: + flow (Tensor): Flow of shape (N, 2, H, W) or (2, H, W) and dtype torch.float. + + Returns: + img (Tensor): Image Tensor of dtype uint8 where each color corresponds + to a given flow direction. Shape is (N, 3, H, W) or (3, H, W) depending on the input. + """ + + if flow.dtype != torch.float: + raise ValueError(f"Flow should be of dtype torch.float, got {flow.dtype}.") + + orig_shape = flow.shape + if flow.ndim == 3: + flow = flow[None] # Add batch dim + + if flow.ndim != 4 or flow.shape[1] != 2: + raise ValueError(f"Input flow should have shape (2, H, W) or (N, 2, H, W), got {orig_shape}.") + + max_norm = torch.sum(flow**2, dim=1).sqrt().max() + epsilon = torch.finfo((flow).dtype).eps + normalized_flow = flow / (max_norm + epsilon) + img = _normalized_flow_to_image(normalized_flow) + + if len(orig_shape) == 3: + img = img[0] # Remove batch dim + return img + + +@torch.no_grad() +def _normalized_flow_to_image(normalized_flow: torch.Tensor) -> torch.Tensor: + """ + Converts a batch of normalized flow to an RGB image. + + Args: + normalized_flow (torch.Tensor): Normalized flow tensor of shape (N, 2, H, W) + Returns: + img (Tensor(N, 3, H, W)): Flow visualization image of dtype uint8. + """ + + N, _, H, W = normalized_flow.shape + device = normalized_flow.device + flow_image = torch.zeros((N, 3, H, W), dtype=torch.uint8, device=device) + colorwheel = _make_colorwheel().to(device) # shape [55x3] + num_cols = colorwheel.shape[0] + norm = torch.sum(normalized_flow**2, dim=1).sqrt() + a = torch.atan2(-normalized_flow[:, 1, :, :], -normalized_flow[:, 0, :, :]) / torch.pi + fk = (a + 1) / 2 * (num_cols - 1) + k0 = torch.floor(fk).to(torch.long) + k1 = k0 + 1 + k1[k1 == num_cols] = 0 + f = fk - k0 + + for c in range(colorwheel.shape[1]): + tmp = colorwheel[:, c] + col0 = tmp[k0] / 255.0 + col1 = tmp[k1] / 255.0 + col = (1 - f) * col0 + f * col1 + col = 1 - norm * (1 - col) + flow_image[:, c, :, :] = torch.floor(255 * col) + return flow_image + + +def _make_colorwheel() -> torch.Tensor: + """ + Generates a color wheel for optical flow visualization as presented in: + Baker et al. "A Database and Evaluation Methodology for Optical Flow" (ICCV, 2007) + URL: http://vision.middlebury.edu/flow/flowEval-iccv07.pdf. + + Returns: + colorwheel (Tensor[55, 3]): Colorwheel Tensor. + """ + + RY = 15 + YG = 6 + GC = 4 + CB = 11 + BM = 13 + MR = 6 + + ncols = RY + YG + GC + CB + BM + MR + colorwheel = torch.zeros((ncols, 3)) + col = 0 + + # RY + colorwheel[0:RY, 0] = 255 + colorwheel[0:RY, 1] = torch.floor(255 * torch.arange(0, RY) / RY) + col = col + RY + # YG + colorwheel[col : col + YG, 0] = 255 - torch.floor(255 * torch.arange(0, YG) / YG) + colorwheel[col : col + YG, 1] = 255 + col = col + YG + # GC + colorwheel[col : col + GC, 1] = 255 + colorwheel[col : col + GC, 2] = torch.floor(255 * torch.arange(0, GC) / GC) + col = col + GC + # CB + colorwheel[col : col + CB, 1] = 255 - torch.floor(255 * torch.arange(CB) / CB) + colorwheel[col : col + CB, 2] = 255 + col = col + CB + # BM + colorwheel[col : col + BM, 2] = 255 + colorwheel[col : col + BM, 0] = torch.floor(255 * torch.arange(0, BM) / BM) + col = col + BM + # MR + colorwheel[col : col + MR, 2] = 255 - torch.floor(255 * torch.arange(MR) / MR) + colorwheel[col : col + MR, 0] = 255 + return colorwheel + + +def _generate_color_palette(num_objects: int): + palette = torch.tensor([2**25 - 1, 2**15 - 1, 2**21 - 1]) + return [tuple((i * palette) % 255) for i in range(num_objects)] + + +def _parse_colors( + colors: Union[None, str, tuple[int, int, int], list[Union[str, tuple[int, int, int]]]], + *, + num_objects: int, + dtype: torch.dtype = torch.uint8, +) -> list[tuple[int, int, int]]: + """ + Parses a specification of colors for a set of objects. + + Args: + colors: A specification of colors for the objects. This can be one of the following: + - None: to generate a color palette automatically. + - A list of colors: where each color is either a string (specifying a named color) or an RGB tuple. + - A string or an RGB tuple: to use the same color for all objects. + + If `colors` is a tuple, it should be a 3-tuple specifying the RGB values of the color. + If `colors` is a list, it should have at least as many elements as the number of objects to color. + + num_objects (int): The number of objects to color. + + Returns: + A list of 3-tuples, specifying the RGB values of the colors. + + Raises: + ValueError: If the number of colors in the list is less than the number of objects to color. + If `colors` is not a list, tuple, string or None. + """ + if colors is None: + colors = _generate_color_palette(num_objects) + elif isinstance(colors, list): + if len(colors) < num_objects: + raise ValueError( + f"Number of colors must be equal or larger than the number of objects, but got {len(colors)} < {num_objects}." + ) + elif not isinstance(colors, (tuple, str)): + raise ValueError(f"`colors` must be a tuple or a string, or a list thereof, but got {colors}.") + elif isinstance(colors, tuple) and len(colors) != 3: + raise ValueError(f"If passed as tuple, colors should be an RGB triplet, but got {colors}.") + else: # colors specifies a single color for all objects + colors = [colors] * num_objects + + colors = [ImageColor.getrgb(color) if isinstance(color, str) else color for color in colors] + if dtype.is_floating_point: # [0, 255] -> [0, 1] + colors = [tuple(v / 255 for v in color) for color in colors] # type: ignore[union-attr] + return colors # type: ignore[return-value] + + +def _log_api_usage_once(obj: Any) -> None: + """ + Logs API usage(module and name) within an organization. + In a large ecosystem, it's often useful to track the PyTorch and + TorchVision APIs usage. This API provides the similar functionality to the + logging module in the Python stdlib. It can be used for debugging purpose + to log which methods are used and by default it is inactive, unless the user + manually subscribes a logger via the `SetAPIUsageLogger method `_. + Please note it is triggered only once for the same API call within a process. + It does not collect any data from open-source users since it is no-op by default. + For more information, please refer to + * PyTorch note: https://pytorch.org/docs/stable/notes/large_scale_deployments.html#api-usage-logging; + * Logging policy: https://github.com/pytorch/vision/issues/5052; + + Args: + obj (class instance or method): an object to extract info from. + """ + module = obj.__module__ + if not module.startswith("torchvision"): + module = f"torchvision.internal.{module}" + name = obj.__class__.__name__ + if isinstance(obj, FunctionType): + name = obj.__name__ + torch._C._log_api_usage_once(f"{module}.{name}") + + +def _make_ntuple(x: Any, n: int) -> tuple[Any, ...]: + """ + Make n-tuple from input x. If x is an iterable, then we just convert it to tuple. + Otherwise, we will make a tuple of length n, all with value of x. + reference: https://github.com/pytorch/pytorch/blob/master/torch/nn/modules/utils.py#L8 + + Args: + x (Any): input value + n (int): length of the resulting tuple + """ + if isinstance(x, collections.abc.Iterable): + return tuple(x) + return tuple(repeat(x, n)) diff --git a/.venv/lib/python3.12/site-packages/torchvision/version.py b/.venv/lib/python3.12/site-packages/torchvision/version.py new file mode 100644 index 0000000000000000000000000000000000000000..c003f79a5faf4b50c90760e7f5600b26dfd8d579 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/torchvision/version.py @@ -0,0 +1,5 @@ +__version__ = '0.23.0+cu128' +git_version = '824e8c8726b65fd9d5abdc9702f81c2b0c4c0dc8' +from torchvision.extension import _check_cuda_version +if _check_cuda_version() > 0: + cuda = _check_cuda_version() diff --git a/src/musubi_tuner/__pycache__/__init__.cpython-312.pyc b/src/musubi_tuner/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..631ae120723dad1a3d477de28af4af0afaf7597e Binary files /dev/null and b/src/musubi_tuner/__pycache__/__init__.cpython-312.pyc differ diff --git a/src/musubi_tuner/__pycache__/audio_loss_balance.cpython-312.pyc b/src/musubi_tuner/__pycache__/audio_loss_balance.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..616d4b6c6f15d9de3cca02f58ef4e60ed40fa190 Binary files /dev/null and b/src/musubi_tuner/__pycache__/audio_loss_balance.cpython-312.pyc differ diff --git a/src/musubi_tuner/__pycache__/audio_supervision.cpython-312.pyc b/src/musubi_tuner/__pycache__/audio_supervision.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb69b34b925c263cb3a2d87bd64f2877c291bebc Binary files /dev/null and b/src/musubi_tuner/__pycache__/audio_supervision.cpython-312.pyc differ diff --git a/src/musubi_tuner/__pycache__/convert_lora.cpython-312.pyc b/src/musubi_tuner/__pycache__/convert_lora.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9da0abe47352bc51adca96ef91d42638396d8549 Binary files /dev/null and b/src/musubi_tuner/__pycache__/convert_lora.cpython-312.pyc differ diff --git a/src/musubi_tuner/gui_dashboard/__main__.py b/src/musubi_tuner/gui_dashboard/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..d50d606cadb9b60c863d990dd52e8af80586a704 --- /dev/null +++ b/src/musubi_tuner/gui_dashboard/__main__.py @@ -0,0 +1,75 @@ +"""Entry point for `python -m musubi_tuner.gui_dashboard`.""" + +import argparse +import logging +import os +import signal +import subprocess +import sys + +import uvicorn + +from musubi_tuner.gui_dashboard.management_server import create_management_app + +logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s") +logger = logging.getLogger(__name__) + +FRONTEND_DIR = os.path.join(os.path.dirname(__file__), "frontend") + + +def main(): + parser = argparse.ArgumentParser(description="LTX-2 Training Manager") + parser.add_argument("--port", type=int, default=7860, help="Server port (default: 7860)") + parser.add_argument("--host", type=str, default="0.0.0.0", help="Server host (default: 0.0.0.0)") + parser.add_argument("--project", type=str, default=None, help="Path to project.json to load on startup") + parser.add_argument("--dev", action="store_true", help="Start Vite dev server alongside the API backend") + parser.add_argument("--dev-port", type=int, default=5173, help="Vite dev server port (default: 5173)") + args = parser.parse_args() + + vite_proc = None + if args.dev: + vite_proc = _start_vite(args.dev_port) + + app = create_management_app(project_path=args.project) + + url = f"http://localhost:{args.dev_port}" if args.dev else f"http://{args.host}:{args.port}" + logger.info(f"Starting LTX-2 Training Manager — open {url}") + + try: + uvicorn.run(app, host=args.host, port=args.port, log_level="info") + finally: + if vite_proc is not None: + _stop_vite(vite_proc) + + +def _start_vite(port: int) -> subprocess.Popen: + """Spawn `npm run dev` in the frontend directory.""" + npm_cmd = "npm.cmd" if sys.platform == "win32" else "npm" + logger.info(f"Starting Vite dev server on port {port} ...") + proc = subprocess.Popen( + [npm_cmd, "run", "dev", "--", "--port", str(port)], + cwd=FRONTEND_DIR, + # Let Vite output go to the same console + stdout=sys.stdout, + stderr=sys.stderr, + ) + return proc + + +def _stop_vite(proc: subprocess.Popen): + """Terminate the Vite dev server.""" + if proc.poll() is not None: + return + logger.info("Stopping Vite dev server ...") + if sys.platform == "win32": + proc.send_signal(signal.CTRL_BREAK_EVENT) + else: + proc.terminate() + try: + proc.wait(timeout=5) + except subprocess.TimeoutExpired: + proc.kill() + + +if __name__ == "__main__": + main() diff --git a/src/musubi_tuner/gui_dashboard/frontend/svelte.config.js b/src/musubi_tuner/gui_dashboard/frontend/svelte.config.js new file mode 100644 index 0000000000000000000000000000000000000000..4a6ccb7e44919bc6d7eefed8d20e2a7f4a482171 --- /dev/null +++ b/src/musubi_tuner/gui_dashboard/frontend/svelte.config.js @@ -0,0 +1,19 @@ +import adapter from '@sveltejs/adapter-static'; + +/** @type {import('@sveltejs/kit').Config} */ +const config = { + kit: { + adapter: adapter({ + pages: 'dist', + assets: 'dist', + fallback: 'index.html', + precompress: false, + strict: false + }), + paths: { + base: '' + } + } +}; + +export default config; diff --git a/src/musubi_tuner/gui_dashboard/frontend/vite.config.js b/src/musubi_tuner/gui_dashboard/frontend/vite.config.js new file mode 100644 index 0000000000000000000000000000000000000000..e9f56bb2d0e0d743af1898f292871201827c4366 --- /dev/null +++ b/src/musubi_tuner/gui_dashboard/frontend/vite.config.js @@ -0,0 +1,18 @@ +import { sveltekit } from '@sveltejs/kit/vite'; +import tailwindcss from '@tailwindcss/vite'; +import { defineConfig } from 'vite'; + +export default defineConfig({ + plugins: [tailwindcss(), sveltekit()], + optimizeDeps: { + exclude: ['@duckdb/duckdb-wasm'] + }, + server: { + hmr: true, + proxy: { + '/api': 'http://localhost:7860', + '/data': 'http://localhost:7860', + '/sse': 'http://localhost:7860' + } + } +}); diff --git a/src/musubi_tuner/hunyuan_model/autoencoder_kl_causal_3d.py b/src/musubi_tuner/hunyuan_model/autoencoder_kl_causal_3d.py new file mode 100644 index 0000000000000000000000000000000000000000..032365e3668dc168760fc347331c498f5e0bb178 --- /dev/null +++ b/src/musubi_tuner/hunyuan_model/autoencoder_kl_causal_3d.py @@ -0,0 +1,609 @@ +# Copyright 2024 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +# +# Modified from diffusers==0.29.2 +# +# ============================================================================== +from typing import Dict, Optional, Tuple, Union +from dataclasses import dataclass + +import torch +import torch.nn as nn + +from diffusers.configuration_utils import ConfigMixin, register_to_config + +# try: +# # This diffusers is modified and packed in the mirror. +# from diffusers.loaders import FromOriginalVAEMixin +# except ImportError: +# # Use this to be compatible with the original diffusers. +# from diffusers.loaders.single_file_model import FromOriginalModelMixin as FromOriginalVAEMixin +from diffusers.utils.accelerate_utils import apply_forward_hook +from diffusers.models.attention_processor import ( + ADDED_KV_ATTENTION_PROCESSORS, + CROSS_ATTENTION_PROCESSORS, + Attention, + AttentionProcessor, + AttnAddedKVProcessor, + AttnProcessor, +) +from diffusers.models.modeling_outputs import AutoencoderKLOutput +from diffusers.models.modeling_utils import ModelMixin +from musubi_tuner.hunyuan_model.vae import DecoderCausal3D, BaseOutput, DecoderOutput, DiagonalGaussianDistribution, EncoderCausal3D + + +@dataclass +class DecoderOutput2(BaseOutput): + sample: torch.FloatTensor + posterior: Optional[DiagonalGaussianDistribution] = None + + +class AutoencoderKLCausal3D(ModelMixin, ConfigMixin): + r""" + A VAE model with KL loss for encoding images/videos into latents and decoding latent representations into images/videos. + + This model inherits from [`ModelMixin`]. Check the superclass documentation for it's generic methods implemented + for all models (such as downloading or saving). + """ + + _supports_gradient_checkpointing = True + + @register_to_config + def __init__( + self, + in_channels: int = 3, + out_channels: int = 3, + down_block_types: Tuple[str] = ("DownEncoderBlockCausal3D",), + up_block_types: Tuple[str] = ("UpDecoderBlockCausal3D",), + block_out_channels: Tuple[int] = (64,), + layers_per_block: int = 1, + act_fn: str = "silu", + latent_channels: int = 4, + norm_num_groups: int = 32, + sample_size: int = 32, + sample_tsize: int = 64, + scaling_factor: float = 0.18215, + force_upcast: float = True, + spatial_compression_ratio: int = 8, + time_compression_ratio: int = 4, + mid_block_add_attention: bool = True, + ): + super().__init__() + + self.time_compression_ratio = time_compression_ratio + + self.encoder = EncoderCausal3D( + in_channels=in_channels, + out_channels=latent_channels, + down_block_types=down_block_types, + block_out_channels=block_out_channels, + layers_per_block=layers_per_block, + act_fn=act_fn, + norm_num_groups=norm_num_groups, + double_z=True, + time_compression_ratio=time_compression_ratio, + spatial_compression_ratio=spatial_compression_ratio, + mid_block_add_attention=mid_block_add_attention, + ) + + self.decoder = DecoderCausal3D( + in_channels=latent_channels, + out_channels=out_channels, + up_block_types=up_block_types, + block_out_channels=block_out_channels, + layers_per_block=layers_per_block, + norm_num_groups=norm_num_groups, + act_fn=act_fn, + time_compression_ratio=time_compression_ratio, + spatial_compression_ratio=spatial_compression_ratio, + mid_block_add_attention=mid_block_add_attention, + ) + + self.quant_conv = nn.Conv3d(2 * latent_channels, 2 * latent_channels, kernel_size=1) + self.post_quant_conv = nn.Conv3d(latent_channels, latent_channels, kernel_size=1) + + self.use_slicing = False + self.use_spatial_tiling = False + self.use_temporal_tiling = False + + # only relevant if vae tiling is enabled + self.tile_sample_min_tsize = sample_tsize + self.tile_latent_min_tsize = sample_tsize // time_compression_ratio + + self.tile_sample_min_size = self.config.sample_size + sample_size = self.config.sample_size[0] if isinstance(self.config.sample_size, (list, tuple)) else self.config.sample_size + self.tile_latent_min_size = int(sample_size / (2 ** (len(self.config.block_out_channels) - 1))) + self.tile_overlap_factor = 0.25 + + def _set_gradient_checkpointing(self, module, value=False): + if isinstance(module, (EncoderCausal3D, DecoderCausal3D)): + module.gradient_checkpointing = value + + def enable_temporal_tiling(self, use_tiling: bool = True): + self.use_temporal_tiling = use_tiling + + def disable_temporal_tiling(self): + self.enable_temporal_tiling(False) + + def enable_spatial_tiling(self, use_tiling: bool = True): + self.use_spatial_tiling = use_tiling + + def disable_spatial_tiling(self): + self.enable_spatial_tiling(False) + + def enable_tiling(self, use_tiling: bool = True): + r""" + Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to + compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow + processing larger videos. + """ + self.enable_spatial_tiling(use_tiling) + self.enable_temporal_tiling(use_tiling) + + def disable_tiling(self): + r""" + Disable tiled VAE decoding. If `enable_tiling` was previously enabled, this method will go back to computing + decoding in one step. + """ + self.disable_spatial_tiling() + self.disable_temporal_tiling() + + def enable_slicing(self): + r""" + Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to + compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. + """ + self.use_slicing = True + + def disable_slicing(self): + r""" + Disable sliced VAE decoding. If `enable_slicing` was previously enabled, this method will go back to computing + decoding in one step. + """ + self.use_slicing = False + + def set_chunk_size_for_causal_conv_3d(self, chunk_size: int): + # set chunk_size to CausalConv3d recursively + def set_chunk_size(module): + if hasattr(module, "chunk_size"): + module.chunk_size = chunk_size + + self.apply(set_chunk_size) + + @property + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.attn_processors + def attn_processors(self) -> Dict[str, AttentionProcessor]: + r""" + Returns: + `dict` of attention processors: A dictionary containing all attention processors used in the model with + indexed by its weight name. + """ + # set recursively + processors = {} + + def fn_recursive_add_processors(name: str, module: torch.nn.Module, processors: Dict[str, AttentionProcessor]): + if hasattr(module, "get_processor"): + processors[f"{name}.processor"] = module.get_processor(return_deprecated_lora=True) + + for sub_name, child in module.named_children(): + fn_recursive_add_processors(f"{name}.{sub_name}", child, processors) + + return processors + + for name, module in self.named_children(): + fn_recursive_add_processors(name, module, processors) + + return processors + + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_attn_processor + def set_attn_processor(self, processor: Union[AttentionProcessor, Dict[str, AttentionProcessor]], _remove_lora=False): + r""" + Sets the attention processor to use to compute attention. + + Parameters: + processor (`dict` of `AttentionProcessor` or only `AttentionProcessor`): + The instantiated processor class or a dictionary of processor classes that will be set as the processor + for **all** `Attention` layers. + + If `processor` is a dict, the key needs to define the path to the corresponding cross attention + processor. This is strongly recommended when setting trainable attention processors. + + """ + count = len(self.attn_processors.keys()) + + if isinstance(processor, dict) and len(processor) != count: + raise ValueError( + f"A dict of processors was passed, but the number of processors {len(processor)} does not match the" + f" number of attention layers: {count}. Please make sure to pass {count} processor classes." + ) + + def fn_recursive_attn_processor(name: str, module: torch.nn.Module, processor): + if hasattr(module, "set_processor"): + if not isinstance(processor, dict): + module.set_processor(processor, _remove_lora=_remove_lora) + else: + module.set_processor(processor.pop(f"{name}.processor"), _remove_lora=_remove_lora) + + for sub_name, child in module.named_children(): + fn_recursive_attn_processor(f"{name}.{sub_name}", child, processor) + + for name, module in self.named_children(): + fn_recursive_attn_processor(name, module, processor) + + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.set_default_attn_processor + def set_default_attn_processor(self): + """ + Disables custom attention processors and sets the default attention implementation. + """ + if all(proc.__class__ in ADDED_KV_ATTENTION_PROCESSORS for proc in self.attn_processors.values()): + processor = AttnAddedKVProcessor() + elif all(proc.__class__ in CROSS_ATTENTION_PROCESSORS for proc in self.attn_processors.values()): + processor = AttnProcessor() + else: + raise ValueError( + f"Cannot call `set_default_attn_processor` when attention processors are of type {next(iter(self.attn_processors.values()))}" + ) + + self.set_attn_processor(processor, _remove_lora=True) + + @apply_forward_hook + def encode( + self, x: torch.FloatTensor, return_dict: bool = True + ) -> Union[AutoencoderKLOutput, Tuple[DiagonalGaussianDistribution]]: + """ + Encode a batch of images/videos into latents. + + Args: + x (`torch.FloatTensor`): Input batch of images/videos. + return_dict (`bool`, *optional*, defaults to `True`): + Whether to return a [`~models.autoencoder_kl.AutoencoderKLOutput`] instead of a plain tuple. + + Returns: + The latent representations of the encoded images/videos. If `return_dict` is True, a + [`~models.autoencoder_kl.AutoencoderKLOutput`] is returned, otherwise a plain `tuple` is returned. + """ + assert len(x.shape) == 5, "The input tensor should have 5 dimensions." + + if self.use_temporal_tiling and x.shape[2] > self.tile_sample_min_tsize: + return self.temporal_tiled_encode(x, return_dict=return_dict) + + if self.use_spatial_tiling and (x.shape[-1] > self.tile_sample_min_size or x.shape[-2] > self.tile_sample_min_size): + return self.spatial_tiled_encode(x, return_dict=return_dict) + + if self.use_slicing and x.shape[0] > 1: + encoded_slices = [self.encoder(x_slice) for x_slice in x.split(1)] + h = torch.cat(encoded_slices) + else: + h = self.encoder(x) + + moments = self.quant_conv(h) + posterior = DiagonalGaussianDistribution(moments) + + if not return_dict: + return (posterior,) + + return AutoencoderKLOutput(latent_dist=posterior) + + def _decode(self, z: torch.FloatTensor, return_dict: bool = True) -> Union[DecoderOutput, torch.FloatTensor]: + assert len(z.shape) == 5, "The input tensor should have 5 dimensions." + + if self.use_temporal_tiling and z.shape[2] > self.tile_latent_min_tsize: + return self.temporal_tiled_decode(z, return_dict=return_dict) + + if self.use_spatial_tiling and (z.shape[-1] > self.tile_latent_min_size or z.shape[-2] > self.tile_latent_min_size): + return self.spatial_tiled_decode(z, return_dict=return_dict) + + z = self.post_quant_conv(z) + dec = self.decoder(z) + + if not return_dict: + return (dec,) + + return DecoderOutput(sample=dec) + + @apply_forward_hook + def decode(self, z: torch.FloatTensor, return_dict: bool = True, generator=None) -> Union[DecoderOutput, torch.FloatTensor]: + """ + Decode a batch of images/videos. + + Args: + z (`torch.FloatTensor`): Input batch of latent vectors. + return_dict (`bool`, *optional*, defaults to `True`): + Whether to return a [`~models.vae.DecoderOutput`] instead of a plain tuple. + + Returns: + [`~models.vae.DecoderOutput`] or `tuple`: + If return_dict is True, a [`~models.vae.DecoderOutput`] is returned, otherwise a plain `tuple` is + returned. + + """ + if self.use_slicing and z.shape[0] > 1: + decoded_slices = [self._decode(z_slice).sample for z_slice in z.split(1)] + decoded = torch.cat(decoded_slices) + else: + decoded = self._decode(z).sample + + if not return_dict: + return (decoded,) + + return DecoderOutput(sample=decoded) + + def blend_v(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor: + blend_extent = min(a.shape[-2], b.shape[-2], blend_extent) + for y in range(blend_extent): + b[:, :, :, y, :] = a[:, :, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, :, y, :] * (y / blend_extent) + return b + + def blend_h(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor: + blend_extent = min(a.shape[-1], b.shape[-1], blend_extent) + for x in range(blend_extent): + b[:, :, :, :, x] = a[:, :, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, :, x] * (x / blend_extent) + return b + + def blend_t(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor: + blend_extent = min(a.shape[-3], b.shape[-3], blend_extent) + for x in range(blend_extent): + b[:, :, x, :, :] = a[:, :, -blend_extent + x, :, :] * (1 - x / blend_extent) + b[:, :, x, :, :] * (x / blend_extent) + return b + + def spatial_tiled_encode( + self, x: torch.FloatTensor, return_dict: bool = True, return_moments: bool = False + ) -> AutoencoderKLOutput: + r"""Encode a batch of images/videos using a tiled encoder. + + When this option is enabled, the VAE will split the input tensor into tiles to compute encoding in several + steps. This is useful to keep memory use constant regardless of image/videos size. The end result of tiled encoding is + different from non-tiled encoding because each tile uses a different encoder. To avoid tiling artifacts, the + tiles overlap and are blended together to form a smooth output. You may still see tile-sized changes in the + output, but they should be much less noticeable. + + Args: + x (`torch.FloatTensor`): Input batch of images/videos. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~models.autoencoder_kl.AutoencoderKLOutput`] instead of a plain tuple. + + Returns: + [`~models.autoencoder_kl.AutoencoderKLOutput`] or `tuple`: + If return_dict is True, a [`~models.autoencoder_kl.AutoencoderKLOutput`] is returned, otherwise a plain + `tuple` is returned. + """ + overlap_size = int(self.tile_sample_min_size * (1 - self.tile_overlap_factor)) + blend_extent = int(self.tile_latent_min_size * self.tile_overlap_factor) + row_limit = self.tile_latent_min_size - blend_extent + + # Split video into tiles and encode them separately. + rows = [] + for i in range(0, x.shape[-2], overlap_size): + row = [] + for j in range(0, x.shape[-1], overlap_size): + tile = x[:, :, :, i : i + self.tile_sample_min_size, j : j + self.tile_sample_min_size] + tile = self.encoder(tile) + tile = self.quant_conv(tile) + row.append(tile) + rows.append(row) + result_rows = [] + for i, row in enumerate(rows): + result_row = [] + for j, tile in enumerate(row): + # blend the above tile and the left tile + # to the current tile and add the current tile to the result row + if i > 0: + tile = self.blend_v(rows[i - 1][j], tile, blend_extent) + if j > 0: + tile = self.blend_h(row[j - 1], tile, blend_extent) + result_row.append(tile[:, :, :, :row_limit, :row_limit]) + result_rows.append(torch.cat(result_row, dim=-1)) + + moments = torch.cat(result_rows, dim=-2) + if return_moments: + return moments + + posterior = DiagonalGaussianDistribution(moments) + if not return_dict: + return (posterior,) + + return AutoencoderKLOutput(latent_dist=posterior) + + def spatial_tiled_decode(self, z: torch.FloatTensor, return_dict: bool = True) -> Union[DecoderOutput, torch.FloatTensor]: + r""" + Decode a batch of images/videos using a tiled decoder. + + Args: + z (`torch.FloatTensor`): Input batch of latent vectors. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~models.vae.DecoderOutput`] instead of a plain tuple. + + Returns: + [`~models.vae.DecoderOutput`] or `tuple`: + If return_dict is True, a [`~models.vae.DecoderOutput`] is returned, otherwise a plain `tuple` is + returned. + """ + overlap_size = int(self.tile_latent_min_size * (1 - self.tile_overlap_factor)) + blend_extent = int(self.tile_sample_min_size * self.tile_overlap_factor) + row_limit = self.tile_sample_min_size - blend_extent + + # Split z into overlapping tiles and decode them separately. + # The tiles have an overlap to avoid seams between tiles. + rows = [] + for i in range(0, z.shape[-2], overlap_size): + row = [] + for j in range(0, z.shape[-1], overlap_size): + tile = z[:, :, :, i : i + self.tile_latent_min_size, j : j + self.tile_latent_min_size] + tile = self.post_quant_conv(tile) + decoded = self.decoder(tile) + row.append(decoded) + rows.append(row) + result_rows = [] + for i, row in enumerate(rows): + result_row = [] + for j, tile in enumerate(row): + # blend the above tile and the left tile + # to the current tile and add the current tile to the result row + if i > 0: + tile = self.blend_v(rows[i - 1][j], tile, blend_extent) + if j > 0: + tile = self.blend_h(row[j - 1], tile, blend_extent) + result_row.append(tile[:, :, :, :row_limit, :row_limit]) + result_rows.append(torch.cat(result_row, dim=-1)) + + dec = torch.cat(result_rows, dim=-2) + if not return_dict: + return (dec,) + + return DecoderOutput(sample=dec) + + def temporal_tiled_encode(self, x: torch.FloatTensor, return_dict: bool = True) -> AutoencoderKLOutput: + + B, C, T, H, W = x.shape + overlap_size = int(self.tile_sample_min_tsize * (1 - self.tile_overlap_factor)) + blend_extent = int(self.tile_latent_min_tsize * self.tile_overlap_factor) + t_limit = self.tile_latent_min_tsize - blend_extent + + # Split the video into tiles and encode them separately. + row = [] + for i in range(0, T, overlap_size): + tile = x[:, :, i : i + self.tile_sample_min_tsize + 1, :, :] + if self.use_spatial_tiling and ( + tile.shape[-1] > self.tile_sample_min_size or tile.shape[-2] > self.tile_sample_min_size + ): + tile = self.spatial_tiled_encode(tile, return_moments=True) + else: + tile = self.encoder(tile) + tile = self.quant_conv(tile) + if i > 0: + tile = tile[:, :, 1:, :, :] + row.append(tile) + result_row = [] + for i, tile in enumerate(row): + if i > 0: + tile = self.blend_t(row[i - 1], tile, blend_extent) + result_row.append(tile[:, :, :t_limit, :, :]) + else: + result_row.append(tile[:, :, : t_limit + 1, :, :]) + + moments = torch.cat(result_row, dim=2) + posterior = DiagonalGaussianDistribution(moments) + + if not return_dict: + return (posterior,) + + return AutoencoderKLOutput(latent_dist=posterior) + + def temporal_tiled_decode(self, z: torch.FloatTensor, return_dict: bool = True) -> Union[DecoderOutput, torch.FloatTensor]: + # Split z into overlapping tiles and decode them separately. + + B, C, T, H, W = z.shape + overlap_size = int(self.tile_latent_min_tsize * (1 - self.tile_overlap_factor)) + blend_extent = int(self.tile_sample_min_tsize * self.tile_overlap_factor) + t_limit = self.tile_sample_min_tsize - blend_extent + + row = [] + for i in range(0, T, overlap_size): + tile = z[:, :, i : i + self.tile_latent_min_tsize + 1, :, :] + if self.use_spatial_tiling and ( + tile.shape[-1] > self.tile_latent_min_size or tile.shape[-2] > self.tile_latent_min_size + ): + decoded = self.spatial_tiled_decode(tile, return_dict=True).sample + else: + tile = self.post_quant_conv(tile) + decoded = self.decoder(tile) + if i > 0: + decoded = decoded[:, :, 1:, :, :] + row.append(decoded) + result_row = [] + for i, tile in enumerate(row): + if i > 0: + tile = self.blend_t(row[i - 1], tile, blend_extent) + result_row.append(tile[:, :, :t_limit, :, :]) + else: + result_row.append(tile[:, :, : t_limit + 1, :, :]) + + dec = torch.cat(result_row, dim=2) + if not return_dict: + return (dec,) + + return DecoderOutput(sample=dec) + + def forward( + self, + sample: torch.FloatTensor, + sample_posterior: bool = False, + return_dict: bool = True, + return_posterior: bool = False, + generator: Optional[torch.Generator] = None, + ) -> Union[DecoderOutput2, torch.FloatTensor]: + r""" + Args: + sample (`torch.FloatTensor`): Input sample. + sample_posterior (`bool`, *optional*, defaults to `False`): + Whether to sample from the posterior. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`DecoderOutput`] instead of a plain tuple. + """ + x = sample + posterior = self.encode(x).latent_dist + if sample_posterior: + z = posterior.sample(generator=generator) + else: + z = posterior.mode() + dec = self.decode(z).sample + + if not return_dict: + if return_posterior: + return (dec, posterior) + else: + return (dec,) + if return_posterior: + return DecoderOutput2(sample=dec, posterior=posterior) + else: + return DecoderOutput2(sample=dec) + + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.fuse_qkv_projections + def fuse_qkv_projections(self): + """ + Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query, + key, value) are fused. For cross-attention modules, key and value projection matrices are fused. + + + + This API is 🧪 experimental. + + + """ + self.original_attn_processors = None + + for _, attn_processor in self.attn_processors.items(): + if "Added" in str(attn_processor.__class__.__name__): + raise ValueError("`fuse_qkv_projections()` is not supported for models having added KV projections.") + + self.original_attn_processors = self.attn_processors + + for module in self.modules(): + if isinstance(module, Attention): + module.fuse_projections(fuse=True) + + # Copied from diffusers.models.unet_2d_condition.UNet2DConditionModel.unfuse_qkv_projections + def unfuse_qkv_projections(self): + """Disables the fused QKV projection if enabled. + + + + This API is 🧪 experimental. + + + + """ + if self.original_attn_processors is not None: + self.set_attn_processor(self.original_attn_processors) diff --git a/src/musubi_tuner/hunyuan_model/mlp_layers.py b/src/musubi_tuner/hunyuan_model/mlp_layers.py new file mode 100644 index 0000000000000000000000000000000000000000..fe9c28155b9129bec4284e6b3ffeefcb5c4a94aa --- /dev/null +++ b/src/musubi_tuner/hunyuan_model/mlp_layers.py @@ -0,0 +1,102 @@ +# Modified from timm library: +# https://github.com/huggingface/pytorch-image-models/blob/648aaa41233ba83eb38faf5ba9d415d574823241/timm/layers/mlp.py#L13 + +from functools import partial + +import torch +import torch.nn as nn + +from musubi_tuner.hunyuan_model.modulate_layers import modulate +from musubi_tuner.hunyuan_model.helpers import to_2tuple + + +class MLP(nn.Module): + """MLP as used in Vision Transformer, MLP-Mixer and related networks""" + + def __init__( + self, + in_channels, + hidden_channels=None, + out_features=None, + act_layer=nn.GELU, + norm_layer=None, + bias=True, + drop=0.0, + use_conv=False, + device=None, + dtype=None, + ): + factory_kwargs = {"device": device, "dtype": dtype} + super().__init__() + out_features = out_features or in_channels + hidden_channels = hidden_channels or in_channels + bias = to_2tuple(bias) + drop_probs = to_2tuple(drop) + linear_layer = partial(nn.Conv2d, kernel_size=1) if use_conv else nn.Linear + + self.fc1 = linear_layer(in_channels, hidden_channels, bias=bias[0], **factory_kwargs) + self.act = act_layer() + self.drop1 = nn.Dropout(drop_probs[0]) + self.norm = norm_layer(hidden_channels, **factory_kwargs) if norm_layer is not None else nn.Identity() + self.fc2 = linear_layer(hidden_channels, out_features, bias=bias[1], **factory_kwargs) + self.drop2 = nn.Dropout(drop_probs[1]) + + def forward(self, x): + x = self.fc1(x) + x = self.act(x) + x = self.drop1(x) + x = self.norm(x) + x = self.fc2(x) + x = self.drop2(x) + return x + + +# +class MLPEmbedder(nn.Module): + """copied from https://github.com/black-forest-labs/flux/blob/main/src/flux/modules/layers.py""" + + def __init__(self, in_dim: int, hidden_dim: int, device=None, dtype=None): + factory_kwargs = {"device": device, "dtype": dtype} + super().__init__() + self.in_layer = nn.Linear(in_dim, hidden_dim, bias=True, **factory_kwargs) + self.silu = nn.SiLU() + self.out_layer = nn.Linear(hidden_dim, hidden_dim, bias=True, **factory_kwargs) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.out_layer(self.silu(self.in_layer(x))) + + +class FinalLayer(nn.Module): + """The final layer of DiT.""" + + def __init__(self, hidden_size, patch_size, out_channels, act_layer, device=None, dtype=None): + factory_kwargs = {"device": device, "dtype": dtype} + super().__init__() + + # Just use LayerNorm for the final layer + self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6, **factory_kwargs) + if isinstance(patch_size, int): + self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True, **factory_kwargs) + else: + self.linear = nn.Linear( + hidden_size, + patch_size[0] * patch_size[1] * patch_size[2] * out_channels, + bias=True, + ) + nn.init.zeros_(self.linear.weight) + nn.init.zeros_(self.linear.bias) + + # Here we don't distinguish between the modulate types. Just use the simple one. + self.adaLN_modulation = nn.Sequential( + act_layer(), + nn.Linear(hidden_size, 2 * hidden_size, bias=True, **factory_kwargs), + ) + # Zero-initialize the modulation + nn.init.zeros_(self.adaLN_modulation[1].weight) + nn.init.zeros_(self.adaLN_modulation[1].bias) + + def forward(self, x, c): + shift, scale = self.adaLN_modulation(c).chunk(2, dim=1) + x = modulate(self.norm_final(x), shift=shift, scale=scale) + x = self.linear(x) + return x diff --git a/src/musubi_tuner/hunyuan_model/modulate_layers.py b/src/musubi_tuner/hunyuan_model/modulate_layers.py new file mode 100644 index 0000000000000000000000000000000000000000..82bd4713b6078f6af8460784cb78c74325cca335 --- /dev/null +++ b/src/musubi_tuner/hunyuan_model/modulate_layers.py @@ -0,0 +1,75 @@ +from typing import Callable + +import torch +import torch.nn as nn + + +class ModulateDiT(nn.Module): + """Modulation layer for DiT.""" + + def __init__( + self, + hidden_size: int, + factor: int, + act_layer: Callable, + dtype=None, + device=None, + ): + factory_kwargs = {"dtype": dtype, "device": device} + super().__init__() + self.act = act_layer() + self.linear = nn.Linear(hidden_size, factor * hidden_size, bias=True, **factory_kwargs) + # Zero-initialize the modulation + nn.init.zeros_(self.linear.weight) + nn.init.zeros_(self.linear.bias) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return self.linear(self.act(x)) + + +def modulate(x, shift=None, scale=None): + """modulate by shift and scale + + Args: + x (torch.Tensor): input tensor. + shift (torch.Tensor, optional): shift tensor. Defaults to None. + scale (torch.Tensor, optional): scale tensor. Defaults to None. + + Returns: + torch.Tensor: the output tensor after modulate. + """ + if scale is None and shift is None: + return x + elif shift is None: + return x * (1 + scale.unsqueeze(1)) + elif scale is None: + return x + shift.unsqueeze(1) + else: + return x * (1 + scale.unsqueeze(1)) + shift.unsqueeze(1) + + +def apply_gate(x, gate=None, tanh=False): + """AI is creating summary for apply_gate + + Args: + x (torch.Tensor): input tensor. + gate (torch.Tensor, optional): gate tensor. Defaults to None. + tanh (bool, optional): whether to use tanh function. Defaults to False. + + Returns: + torch.Tensor: the output tensor after apply gate. + """ + if gate is None: + return x + if tanh: + return x * gate.unsqueeze(1).tanh() + else: + return x * gate.unsqueeze(1) + + +def ckpt_wrapper(module): + def ckpt_forward(*inputs): + outputs = module(*inputs) + return outputs + + return ckpt_forward diff --git a/src/musubi_tuner/hunyuan_model/posemb_layers.py b/src/musubi_tuner/hunyuan_model/posemb_layers.py new file mode 100644 index 0000000000000000000000000000000000000000..6bfe5f1515e7a0b53301a92cfbc73b3e8c286fb9 --- /dev/null +++ b/src/musubi_tuner/hunyuan_model/posemb_layers.py @@ -0,0 +1,286 @@ +import torch +from typing import Union, Tuple, List + + +def _to_tuple(x, dim=2): + if isinstance(x, int): + return (x,) * dim + elif len(x) == dim: + return x + else: + raise ValueError(f"Expected length {dim} or int, but got {x}") + + +def get_meshgrid_nd(start, *args, dim=2): + """ + Get n-D meshgrid with start, stop and num. + + Args: + start (int or tuple): If len(args) == 0, start is num; If len(args) == 1, start is start, args[0] is stop, + step is 1; If len(args) == 2, start is start, args[0] is stop, args[1] is num. For n-dim, start/stop/num + should be int or n-tuple. If n-tuple is provided, the meshgrid will be stacked following the dim order in + n-tuples. + *args: See above. + dim (int): Dimension of the meshgrid. Defaults to 2. + + Returns: + grid (np.ndarray): [dim, ...] + """ + if len(args) == 0: + # start is grid_size + num = _to_tuple(start, dim=dim) + start = (0,) * dim + stop = num + elif len(args) == 1: + # start is start, args[0] is stop, step is 1 + start = _to_tuple(start, dim=dim) + stop = _to_tuple(args[0], dim=dim) + num = [stop[i] - start[i] for i in range(dim)] + elif len(args) == 2: + # start is start, args[0] is stop, args[1] is num + start = _to_tuple(start, dim=dim) # Left-Top eg: 12,0 + stop = _to_tuple(args[0], dim=dim) # Right-Bottom eg: 20,32 + num = _to_tuple(args[1], dim=dim) # Target Size eg: 32,124 + else: + raise ValueError(f"len(args) should be 0, 1 or 2, but got {len(args)}") + + # PyTorch implement of np.linspace(start[i], stop[i], num[i], endpoint=False) + axis_grid = [] + for i in range(dim): + a, b, n = start[i], stop[i], num[i] + g = torch.linspace(a, b, n + 1, dtype=torch.float32)[:n] + axis_grid.append(g) + grid = torch.meshgrid(*axis_grid, indexing="ij") # dim x [W, H, D] + grid = torch.stack(grid, dim=0) # [dim, W, H, D] + + return grid + + +################################################################################# +# Rotary Positional Embedding Functions # +################################################################################# +# https://github.com/meta-llama/llama/blob/be327c427cc5e89cc1d3ab3d3fec4484df771245/llama/model.py#L80 + + +def reshape_for_broadcast( + freqs_cis: Union[torch.Tensor, Tuple[torch.Tensor]], + x: torch.Tensor, + head_first=False, +): + """ + Reshape frequency tensor for broadcasting it with another tensor. + + This function reshapes the frequency tensor to have the same shape as the target tensor 'x' + for the purpose of broadcasting the frequency tensor during element-wise operations. + + Notes: + When using FlashMHAModified, head_first should be False. + When using Attention, head_first should be True. + + Args: + freqs_cis (Union[torch.Tensor, Tuple[torch.Tensor]]): Frequency tensor to be reshaped. + x (torch.Tensor): Target tensor for broadcasting compatibility. + head_first (bool): head dimension first (except batch dim) or not. + + Returns: + torch.Tensor: Reshaped frequency tensor. + + Raises: + AssertionError: If the frequency tensor doesn't match the expected shape. + AssertionError: If the target tensor 'x' doesn't have the expected number of dimensions. + """ + ndim = x.ndim + assert 0 <= 1 < ndim + + if isinstance(freqs_cis, tuple): + # freqs_cis: (cos, sin) in real space + if head_first: + assert freqs_cis[0].shape == ( + x.shape[-2], + x.shape[-1], + ), f"freqs_cis shape {freqs_cis[0].shape} does not match x shape {x.shape}" + shape = [d if i == ndim - 2 or i == ndim - 1 else 1 for i, d in enumerate(x.shape)] + else: + assert freqs_cis[0].shape == ( + x.shape[1], + x.shape[-1], + ), f"freqs_cis shape {freqs_cis[0].shape} does not match x shape {x.shape}" + shape = [d if i == 1 or i == ndim - 1 else 1 for i, d in enumerate(x.shape)] + return freqs_cis[0].view(*shape), freqs_cis[1].view(*shape) + else: + # freqs_cis: values in complex space + if head_first: + assert freqs_cis.shape == ( + x.shape[-2], + x.shape[-1], + ), f"freqs_cis shape {freqs_cis.shape} does not match x shape {x.shape}" + shape = [d if i == ndim - 2 or i == ndim - 1 else 1 for i, d in enumerate(x.shape)] + else: + assert freqs_cis.shape == ( + x.shape[1], + x.shape[-1], + ), f"freqs_cis shape {freqs_cis.shape} does not match x shape {x.shape}" + shape = [d if i == 1 or i == ndim - 1 else 1 for i, d in enumerate(x.shape)] + return freqs_cis.view(*shape) + + +def rotate_half(x): + x_real, x_imag = x.float().reshape(*x.shape[:-1], -1, 2).unbind(-1) # [B, S, H, D//2] + return torch.stack([-x_imag, x_real], dim=-1).flatten(3) + + +def apply_rotary_emb( + xq: torch.Tensor, + xk: torch.Tensor, + freqs_cis: Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]], + head_first: bool = False, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Apply rotary embeddings to input tensors using the given frequency tensor. + + This function applies rotary embeddings to the given query 'xq' and key 'xk' tensors using the provided + frequency tensor 'freqs_cis'. The input tensors are reshaped as complex numbers, and the frequency tensor + is reshaped for broadcasting compatibility. The resulting tensors contain rotary embeddings and are + returned as real tensors. + + Args: + xq (torch.Tensor): Query tensor to apply rotary embeddings. [B, S, H, D] + xk (torch.Tensor): Key tensor to apply rotary embeddings. [B, S, H, D] + freqs_cis (torch.Tensor or tuple): Precomputed frequency tensor for complex exponential. + head_first (bool): head dimension first (except batch dim) or not. + + Returns: + Tuple[torch.Tensor, torch.Tensor]: Tuple of modified query tensor and key tensor with rotary embeddings. + + """ + xk_out = None + if isinstance(freqs_cis, tuple): + cos, sin = reshape_for_broadcast(freqs_cis, xq, head_first) # [S, D] + cos, sin = cos.to(xq.device), sin.to(xq.device) + # real * cos - imag * sin + # imag * cos + real * sin + xq_out = (xq.float() * cos + rotate_half(xq.float()) * sin).type_as(xq) + xk_out = (xk.float() * cos + rotate_half(xk.float()) * sin).type_as(xk) + else: + # view_as_complex will pack [..., D/2, 2](real) to [..., D/2](complex) + xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2)) # [B, S, H, D//2] + freqs_cis = reshape_for_broadcast(freqs_cis, xq_, head_first).to(xq.device) # [S, D//2] --> [1, S, 1, D//2] + # (real, imag) * (cos, sin) = (real * cos - imag * sin, imag * cos + real * sin) + # view_as_real will expand [..., D/2](complex) to [..., D/2, 2](real) + xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3).type_as(xq) + xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2)) # [B, S, H, D//2] + xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3).type_as(xk) + + return xq_out, xk_out + + +def get_nd_rotary_pos_embed( + rope_dim_list, + start, + *args, + theta=10000.0, + use_real=False, + theta_rescale_factor: Union[float, List[float]] = 1.0, + interpolation_factor: Union[float, List[float]] = 1.0, +): + """ + This is a n-d version of precompute_freqs_cis, which is a RoPE for tokens with n-d structure. + + Args: + rope_dim_list (list of int): Dimension of each rope. len(rope_dim_list) should equal to n. + sum(rope_dim_list) should equal to head_dim of attention layer. + start (int | tuple of int | list of int): If len(args) == 0, start is num; If len(args) == 1, start is start, + args[0] is stop, step is 1; If len(args) == 2, start is start, args[0] is stop, args[1] is num. + *args: See above. + theta (float): Scaling factor for frequency computation. Defaults to 10000.0. + use_real (bool): If True, return real part and imaginary part separately. Otherwise, return complex numbers. + Some libraries such as TensorRT does not support complex64 data type. So it is useful to provide a real + part and an imaginary part separately. + theta_rescale_factor (float): Rescale factor for theta. Defaults to 1.0. + + Returns: + pos_embed (torch.Tensor): [HW, D/2] + """ + + grid = get_meshgrid_nd(start, *args, dim=len(rope_dim_list)) # [3, W, H, D] / [2, W, H] + + if isinstance(theta_rescale_factor, int) or isinstance(theta_rescale_factor, float): + theta_rescale_factor = [theta_rescale_factor] * len(rope_dim_list) + elif isinstance(theta_rescale_factor, list) and len(theta_rescale_factor) == 1: + theta_rescale_factor = [theta_rescale_factor[0]] * len(rope_dim_list) + assert len(theta_rescale_factor) == len(rope_dim_list), "len(theta_rescale_factor) should equal to len(rope_dim_list)" + + if isinstance(interpolation_factor, int) or isinstance(interpolation_factor, float): + interpolation_factor = [interpolation_factor] * len(rope_dim_list) + elif isinstance(interpolation_factor, list) and len(interpolation_factor) == 1: + interpolation_factor = [interpolation_factor[0]] * len(rope_dim_list) + assert len(interpolation_factor) == len(rope_dim_list), "len(interpolation_factor) should equal to len(rope_dim_list)" + + # use 1/ndim of dimensions to encode grid_axis + embs = [] + for i in range(len(rope_dim_list)): + emb = get_1d_rotary_pos_embed( + rope_dim_list[i], + grid[i].reshape(-1), + theta, + use_real=use_real, + theta_rescale_factor=theta_rescale_factor[i], + interpolation_factor=interpolation_factor[i], + ) # 2 x [WHD, rope_dim_list[i]] + embs.append(emb) + + if use_real: + cos = torch.cat([emb[0] for emb in embs], dim=1) # (WHD, D/2) + sin = torch.cat([emb[1] for emb in embs], dim=1) # (WHD, D/2) + return cos, sin + else: + emb = torch.cat(embs, dim=1) # (WHD, D/2) + return emb + + +def get_1d_rotary_pos_embed( + dim: int, + pos: Union[torch.FloatTensor, int], + theta: float = 10000.0, + use_real: bool = False, + theta_rescale_factor: float = 1.0, + interpolation_factor: float = 1.0, +) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + """ + Precompute the frequency tensor for complex exponential (cis) with given dimensions. + (Note: `cis` means `cos + i * sin`, where i is the imaginary unit.) + + This function calculates a frequency tensor with complex exponential using the given dimension 'dim' + and the end index 'end'. The 'theta' parameter scales the frequencies. + The returned tensor contains complex values in complex64 data type. + + Args: + dim (int): Dimension of the frequency tensor. + pos (int or torch.FloatTensor): Position indices for the frequency tensor. [S] or scalar + theta (float, optional): Scaling factor for frequency computation. Defaults to 10000.0. + use_real (bool, optional): If True, return real part and imaginary part separately. + Otherwise, return complex numbers. + theta_rescale_factor (float, optional): Rescale factor for theta. Defaults to 1.0. + + Returns: + freqs_cis: Precomputed frequency tensor with complex exponential. [S, D/2] + freqs_cos, freqs_sin: Precomputed frequency tensor with real and imaginary parts separately. [S, D] + """ + if isinstance(pos, int): + pos = torch.arange(pos).float() + + # proposed by reddit user bloc97, to rescale rotary embeddings to longer sequence length without fine-tuning + # has some connection to NTK literature + if theta_rescale_factor != 1.0: + theta *= theta_rescale_factor ** (dim / (dim - 2)) + + freqs = 1.0 / (theta ** (torch.arange(0, dim, 2)[: (dim // 2)].float() / dim)) # [D/2] + # assert interpolation_factor == 1.0, f"interpolation_factor: {interpolation_factor}" + freqs = torch.outer(pos * interpolation_factor, freqs) # [S, D/2] + if use_real: + freqs_cos = freqs.cos().repeat_interleave(2, dim=1) # [S, D] + freqs_sin = freqs.sin().repeat_interleave(2, dim=1) # [S, D] + return freqs_cos, freqs_sin + else: + freqs_cis = torch.polar(torch.ones_like(freqs), freqs) # complex64 # [S, D/2] + return freqs_cis diff --git a/src/musubi_tuner/hunyuan_model/token_refiner.py b/src/musubi_tuner/hunyuan_model/token_refiner.py new file mode 100644 index 0000000000000000000000000000000000000000..252c657ee4ffc4a4e9db0e450f44eabf841b9215 --- /dev/null +++ b/src/musubi_tuner/hunyuan_model/token_refiner.py @@ -0,0 +1,246 @@ +from typing import Optional + +from einops import rearrange +import torch +import torch.nn as nn +from torch.utils.checkpoint import checkpoint + +from musubi_tuner.hunyuan_model.activation_layers import get_activation_layer +from musubi_tuner.hunyuan_model.attention import attention +from musubi_tuner.hunyuan_model.norm_layers import get_norm_layer +from musubi_tuner.hunyuan_model.embed_layers import TimestepEmbedder, TextProjection +from musubi_tuner.hunyuan_model.mlp_layers import MLP + + +class IndividualTokenRefinerBlock(nn.Module): + def __init__( + self, + hidden_size, + heads_num, + mlp_width_ratio: str = 4.0, + mlp_drop_rate: float = 0.0, + act_type: str = "silu", + qk_norm: bool = False, + qk_norm_type: str = "layer", + qkv_bias: bool = True, + dtype: Optional[torch.dtype] = None, + device: Optional[torch.device] = None, + ): + factory_kwargs = {"device": device, "dtype": dtype} + super().__init__() + self.heads_num = heads_num + head_dim = hidden_size // heads_num + mlp_hidden_dim = int(hidden_size * mlp_width_ratio) + + self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=True, eps=1e-6, **factory_kwargs) + self.self_attn_qkv = nn.Linear(hidden_size, hidden_size * 3, bias=qkv_bias, **factory_kwargs) + qk_norm_layer = get_norm_layer(qk_norm_type) + self.self_attn_q_norm = ( + qk_norm_layer(head_dim, elementwise_affine=True, eps=1e-6, **factory_kwargs) if qk_norm else nn.Identity() + ) + self.self_attn_k_norm = ( + qk_norm_layer(head_dim, elementwise_affine=True, eps=1e-6, **factory_kwargs) if qk_norm else nn.Identity() + ) + self.self_attn_proj = nn.Linear(hidden_size, hidden_size, bias=qkv_bias, **factory_kwargs) + + self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=True, eps=1e-6, **factory_kwargs) + act_layer = get_activation_layer(act_type) + self.mlp = MLP( + in_channels=hidden_size, + hidden_channels=mlp_hidden_dim, + act_layer=act_layer, + drop=mlp_drop_rate, + **factory_kwargs, + ) + + self.adaLN_modulation = nn.Sequential( + act_layer(), + nn.Linear(hidden_size, 2 * hidden_size, bias=True, **factory_kwargs), + ) + # Zero-initialize the modulation + nn.init.zeros_(self.adaLN_modulation[1].weight) + nn.init.zeros_(self.adaLN_modulation[1].bias) + + self.gradient_checkpointing = False + + def enable_gradient_checkpointing(self): + self.gradient_checkpointing = True + + def disable_gradient_checkpointing(self): + self.gradient_checkpointing = False + + def _forward( + self, + x: torch.Tensor, + c: torch.Tensor, # timestep_aware_representations + context_aware_representations + attn_mask: torch.Tensor = None, + ): + gate_msa, gate_mlp = self.adaLN_modulation(c).chunk(2, dim=1) + + norm_x = self.norm1(x) + qkv = self.self_attn_qkv(norm_x) + q, k, v = rearrange(qkv, "B L (K H D) -> K B L H D", K=3, H=self.heads_num) + # Apply QK-Norm if needed + q = self.self_attn_q_norm(q).to(v) + k = self.self_attn_k_norm(k).to(v) + + # Self-Attention + attn = attention(q, k, v, mode="torch", attn_mask=attn_mask) + + # x = x + apply_gate(self.self_attn_proj(attn), gate_msa) + x = torch.addcmul(x, self.self_attn_proj(attn), gate_msa.unsqueeze(1)) + + # FFN Layer + # x = x + apply_gate(self.mlp(self.norm2(x)), gate_mlp) + x = torch.addcmul(x, self.mlp(self.norm2(x)), gate_mlp.unsqueeze(1)) + + return x + + def forward(self, *args, **kwargs): + if self.training and self.gradient_checkpointing: + return checkpoint(self._forward, *args, use_reentrant=False, **kwargs) + else: + return self._forward(*args, **kwargs) + + +class IndividualTokenRefiner(nn.Module): + def __init__( + self, + hidden_size, + heads_num, + depth, + mlp_width_ratio: float = 4.0, + mlp_drop_rate: float = 0.0, + act_type: str = "silu", + qk_norm: bool = False, + qk_norm_type: str = "layer", + qkv_bias: bool = True, + dtype: Optional[torch.dtype] = None, + device: Optional[torch.device] = None, + ): + factory_kwargs = {"device": device, "dtype": dtype} + super().__init__() + self.blocks = nn.ModuleList( + [ + IndividualTokenRefinerBlock( + hidden_size=hidden_size, + heads_num=heads_num, + mlp_width_ratio=mlp_width_ratio, + mlp_drop_rate=mlp_drop_rate, + act_type=act_type, + qk_norm=qk_norm, + qk_norm_type=qk_norm_type, + qkv_bias=qkv_bias, + **factory_kwargs, + ) + for _ in range(depth) + ] + ) + + def enable_gradient_checkpointing(self): + for block in self.blocks: + block.enable_gradient_checkpointing() + + def disable_gradient_checkpointing(self): + for block in self.blocks: + block.disable_gradient_checkpointing() + + def forward( + self, + x: torch.Tensor, + c: torch.LongTensor, + mask: Optional[torch.Tensor] = None, + ): + self_attn_mask = None + if mask is not None: + batch_size = mask.shape[0] + seq_len = mask.shape[1] + mask = mask.to(x.device) + # batch_size x 1 x seq_len x seq_len + self_attn_mask_1 = mask.view(batch_size, 1, 1, seq_len).repeat(1, 1, seq_len, 1) + # batch_size x 1 x seq_len x seq_len + self_attn_mask_2 = self_attn_mask_1.transpose(2, 3) + # batch_size x 1 x seq_len x seq_len, 1 for broadcasting of heads_num + self_attn_mask = (self_attn_mask_1 & self_attn_mask_2).bool() + # avoids self-attention weight being NaN for padding tokens + self_attn_mask[:, :, :, 0] = True + + for block in self.blocks: + x = block(x, c, self_attn_mask) + return x + + +class SingleTokenRefiner(nn.Module): + """ + A single token refiner block for llm text embedding refine. + """ + + def __init__( + self, + in_channels, + hidden_size, + heads_num, + depth, + mlp_width_ratio: float = 4.0, + mlp_drop_rate: float = 0.0, + act_type: str = "silu", + qk_norm: bool = False, + qk_norm_type: str = "layer", + qkv_bias: bool = True, + attn_mode: str = "torch", + dtype: Optional[torch.dtype] = None, + device: Optional[torch.device] = None, + ): + factory_kwargs = {"device": device, "dtype": dtype} + super().__init__() + self.attn_mode = attn_mode + assert self.attn_mode == "torch", "Only support 'torch' mode for token refiner." + + self.input_embedder = nn.Linear(in_channels, hidden_size, bias=True, **factory_kwargs) + + act_layer = get_activation_layer(act_type) + # Build timestep embedding layer + self.t_embedder = TimestepEmbedder(hidden_size, act_layer, **factory_kwargs) + # Build context embedding layer + self.c_embedder = TextProjection(in_channels, hidden_size, act_layer, **factory_kwargs) + + self.individual_token_refiner = IndividualTokenRefiner( + hidden_size=hidden_size, + heads_num=heads_num, + depth=depth, + mlp_width_ratio=mlp_width_ratio, + mlp_drop_rate=mlp_drop_rate, + act_type=act_type, + qk_norm=qk_norm, + qk_norm_type=qk_norm_type, + qkv_bias=qkv_bias, + **factory_kwargs, + ) + + def enable_gradient_checkpointing(self): + self.individual_token_refiner.enable_gradient_checkpointing() + + def disable_gradient_checkpointing(self): + self.individual_token_refiner.disable_gradient_checkpointing() + + def forward( + self, + x: torch.Tensor, + t: torch.LongTensor, + mask: Optional[torch.LongTensor] = None, + ): + timestep_aware_representations = self.t_embedder(t) + + if mask is None: + context_aware_representations = x.mean(dim=1) + else: + mask_float = mask.float().unsqueeze(-1) # [b, s1, 1] + context_aware_representations = (x * mask_float).sum(dim=1) / mask_float.sum(dim=1) + context_aware_representations = self.c_embedder(context_aware_representations) + c = timestep_aware_representations + context_aware_representations + + x = self.input_embedder(x) + + x = self.individual_token_refiner(x, c, mask) + + return x diff --git a/src/musubi_tuner/hunyuan_model/vae.py b/src/musubi_tuner/hunyuan_model/vae.py new file mode 100644 index 0000000000000000000000000000000000000000..9bbc3ea95964ae79195235d4f5094bf93f69ae5d --- /dev/null +++ b/src/musubi_tuner/hunyuan_model/vae.py @@ -0,0 +1,447 @@ +from dataclasses import dataclass +import json +from typing import Optional, Tuple, Union +from pathlib import Path + +import numpy as np +import torch +import torch.nn as nn + +from diffusers.utils import BaseOutput, is_torch_version +from diffusers.utils.torch_utils import randn_tensor +from diffusers.models.attention_processor import SpatialNorm +from musubi_tuner.modules.unet_causal_3d_blocks import CausalConv3d, UNetMidBlockCausal3D, get_down_block3d, get_up_block3d + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +SCALING_FACTOR = 0.476986 +VAE_VER = "884-16c-hy" # We don't support other versions currently + + +def load_vae( + vae_type: str = "884-16c-hy", + vae_dtype: Optional[Union[str, torch.dtype]] = None, + sample_size: tuple = None, + vae_path: str = None, + device=None, +): + """the fucntion to load the 3D VAE model + + Args: + vae_type (str): the type of the 3D VAE model. Defaults to "884-16c-hy". + vae_precision (str, optional): the precision to load vae. Defaults to None. + sample_size (tuple, optional): the tiling size. Defaults to None. + vae_path (str, optional): the path to vae. Defaults to None. + logger (_type_, optional): logger. Defaults to None. + device (_type_, optional): device to load vae. Defaults to None. + """ + assert vae_path is not None, "VAE path must be specified" + assert Path(vae_path).exists(), f"VAE path does not exist: {vae_path}" + + logger.info(f"Loading 3D VAE model ({vae_type}) from: {vae_path}") + + # use fixed config for Hunyuan's VAE + CONFIG_JSON = """{ + "_class_name": "AutoencoderKLCausal3D", + "_diffusers_version": "0.4.2", + "act_fn": "silu", + "block_out_channels": [ + 128, + 256, + 512, + 512 + ], + "down_block_types": [ + "DownEncoderBlockCausal3D", + "DownEncoderBlockCausal3D", + "DownEncoderBlockCausal3D", + "DownEncoderBlockCausal3D" + ], + "in_channels": 3, + "latent_channels": 16, + "layers_per_block": 2, + "norm_num_groups": 32, + "out_channels": 3, + "sample_size": 256, + "sample_tsize": 64, + "up_block_types": [ + "UpDecoderBlockCausal3D", + "UpDecoderBlockCausal3D", + "UpDecoderBlockCausal3D", + "UpDecoderBlockCausal3D" + ], + "scaling_factor": 0.476986, + "time_compression_ratio": 4, + "mid_block_add_attention": true + }""" + + # config = AutoencoderKLCausal3D.load_config(vae_path) + config = json.loads(CONFIG_JSON) + + # import here to avoid circular import + from musubi_tuner.hunyuan_model.autoencoder_kl_causal_3d import AutoencoderKLCausal3D + + if sample_size: + vae = AutoencoderKLCausal3D.from_config(config, sample_size=sample_size) + else: + vae = AutoencoderKLCausal3D.from_config(config) + + # vae_ckpt = Path(vae_path) / "pytorch_model.pt" + # assert vae_ckpt.exists(), f"VAE checkpoint not found: {vae_ckpt}" + + if vae_path.endswith(".safetensors"): + from safetensors.torch import load_file + + ckpt = load_file(vae_path) + else: + ckpt = torch.load(vae_path, map_location=vae.device, weights_only=True) + if "state_dict" in ckpt: + ckpt = ckpt["state_dict"] + if any(k.startswith("vae.") for k in ckpt.keys()): + ckpt = {k.replace("vae.", ""): v for k, v in ckpt.items() if k.startswith("vae.")} + vae.load_state_dict(ckpt) + + spatial_compression_ratio = vae.config.spatial_compression_ratio + time_compression_ratio = vae.config.time_compression_ratio + + if vae_dtype is not None: + vae = vae.to(vae_dtype) + + vae.requires_grad_(False) + + logger.info(f"VAE to dtype: {vae.dtype}") + + if device is not None: + vae = vae.to(device) + + vae.eval() + + return vae, vae_path, spatial_compression_ratio, time_compression_ratio + + +@dataclass +class DecoderOutput(BaseOutput): + r""" + Output of decoding method. + + Args: + sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`): + The decoded output sample from the last layer of the model. + """ + + sample: torch.FloatTensor + + +class EncoderCausal3D(nn.Module): + r""" + The `EncoderCausal3D` layer of a variational autoencoder that encodes its input into a latent representation. + """ + + def __init__( + self, + in_channels: int = 3, + out_channels: int = 3, + down_block_types: Tuple[str, ...] = ("DownEncoderBlockCausal3D",), + block_out_channels: Tuple[int, ...] = (64,), + layers_per_block: int = 2, + norm_num_groups: int = 32, + act_fn: str = "silu", + double_z: bool = True, + mid_block_add_attention=True, + time_compression_ratio: int = 4, + spatial_compression_ratio: int = 8, + ): + super().__init__() + self.layers_per_block = layers_per_block + + self.conv_in = CausalConv3d(in_channels, block_out_channels[0], kernel_size=3, stride=1) + self.mid_block = None + self.down_blocks = nn.ModuleList([]) + + # down + output_channel = block_out_channels[0] + for i, down_block_type in enumerate(down_block_types): + input_channel = output_channel + output_channel = block_out_channels[i] + is_final_block = i == len(block_out_channels) - 1 + num_spatial_downsample_layers = int(np.log2(spatial_compression_ratio)) + num_time_downsample_layers = int(np.log2(time_compression_ratio)) + + if time_compression_ratio == 4: + add_spatial_downsample = bool(i < num_spatial_downsample_layers) + add_time_downsample = bool(i >= (len(block_out_channels) - 1 - num_time_downsample_layers) and not is_final_block) + else: + raise ValueError(f"Unsupported time_compression_ratio: {time_compression_ratio}.") + + downsample_stride_HW = (2, 2) if add_spatial_downsample else (1, 1) + downsample_stride_T = (2,) if add_time_downsample else (1,) + downsample_stride = tuple(downsample_stride_T + downsample_stride_HW) + down_block = get_down_block3d( + down_block_type, + num_layers=self.layers_per_block, + in_channels=input_channel, + out_channels=output_channel, + add_downsample=bool(add_spatial_downsample or add_time_downsample), + downsample_stride=downsample_stride, + resnet_eps=1e-6, + downsample_padding=0, + resnet_act_fn=act_fn, + resnet_groups=norm_num_groups, + attention_head_dim=output_channel, + temb_channels=None, + ) + self.down_blocks.append(down_block) + + # mid + self.mid_block = UNetMidBlockCausal3D( + in_channels=block_out_channels[-1], + resnet_eps=1e-6, + resnet_act_fn=act_fn, + output_scale_factor=1, + resnet_time_scale_shift="default", + attention_head_dim=block_out_channels[-1], + resnet_groups=norm_num_groups, + temb_channels=None, + add_attention=mid_block_add_attention, + ) + + # out + self.conv_norm_out = nn.GroupNorm(num_channels=block_out_channels[-1], num_groups=norm_num_groups, eps=1e-6) + self.conv_act = nn.SiLU() + + conv_out_channels = 2 * out_channels if double_z else out_channels + self.conv_out = CausalConv3d(block_out_channels[-1], conv_out_channels, kernel_size=3) + + def forward(self, sample: torch.FloatTensor) -> torch.FloatTensor: + r"""The forward method of the `EncoderCausal3D` class.""" + assert len(sample.shape) == 5, "The input tensor should have 5 dimensions" + + sample = self.conv_in(sample) + + # down + for down_block in self.down_blocks: + sample = down_block(sample) + + # middle + sample = self.mid_block(sample) + + # post-process + sample = self.conv_norm_out(sample) + sample = self.conv_act(sample) + sample = self.conv_out(sample) + + return sample + + +class DecoderCausal3D(nn.Module): + r""" + The `DecoderCausal3D` layer of a variational autoencoder that decodes its latent representation into an output sample. + """ + + def __init__( + self, + in_channels: int = 3, + out_channels: int = 3, + up_block_types: Tuple[str, ...] = ("UpDecoderBlockCausal3D",), + block_out_channels: Tuple[int, ...] = (64,), + layers_per_block: int = 2, + norm_num_groups: int = 32, + act_fn: str = "silu", + norm_type: str = "group", # group, spatial + mid_block_add_attention=True, + time_compression_ratio: int = 4, + spatial_compression_ratio: int = 8, + ): + super().__init__() + self.layers_per_block = layers_per_block + + self.conv_in = CausalConv3d(in_channels, block_out_channels[-1], kernel_size=3, stride=1) + self.mid_block = None + self.up_blocks = nn.ModuleList([]) + + temb_channels = in_channels if norm_type == "spatial" else None + + # mid + self.mid_block = UNetMidBlockCausal3D( + in_channels=block_out_channels[-1], + resnet_eps=1e-6, + resnet_act_fn=act_fn, + output_scale_factor=1, + resnet_time_scale_shift="default" if norm_type == "group" else norm_type, + attention_head_dim=block_out_channels[-1], + resnet_groups=norm_num_groups, + temb_channels=temb_channels, + add_attention=mid_block_add_attention, + ) + + # up + reversed_block_out_channels = list(reversed(block_out_channels)) + output_channel = reversed_block_out_channels[0] + for i, up_block_type in enumerate(up_block_types): + prev_output_channel = output_channel + output_channel = reversed_block_out_channels[i] + is_final_block = i == len(block_out_channels) - 1 + num_spatial_upsample_layers = int(np.log2(spatial_compression_ratio)) + num_time_upsample_layers = int(np.log2(time_compression_ratio)) + + if time_compression_ratio == 4: + add_spatial_upsample = bool(i < num_spatial_upsample_layers) + add_time_upsample = bool(i >= len(block_out_channels) - 1 - num_time_upsample_layers and not is_final_block) + else: + raise ValueError(f"Unsupported time_compression_ratio: {time_compression_ratio}.") + + upsample_scale_factor_HW = (2, 2) if add_spatial_upsample else (1, 1) + upsample_scale_factor_T = (2,) if add_time_upsample else (1,) + upsample_scale_factor = tuple(upsample_scale_factor_T + upsample_scale_factor_HW) + up_block = get_up_block3d( + up_block_type, + num_layers=self.layers_per_block + 1, + in_channels=prev_output_channel, + out_channels=output_channel, + prev_output_channel=None, + add_upsample=bool(add_spatial_upsample or add_time_upsample), + upsample_scale_factor=upsample_scale_factor, + resnet_eps=1e-6, + resnet_act_fn=act_fn, + resnet_groups=norm_num_groups, + attention_head_dim=output_channel, + temb_channels=temb_channels, + resnet_time_scale_shift=norm_type, + ) + self.up_blocks.append(up_block) + prev_output_channel = output_channel + + # out + if norm_type == "spatial": + self.conv_norm_out = SpatialNorm(block_out_channels[0], temb_channels) + else: + self.conv_norm_out = nn.GroupNorm(num_channels=block_out_channels[0], num_groups=norm_num_groups, eps=1e-6) + self.conv_act = nn.SiLU() + self.conv_out = CausalConv3d(block_out_channels[0], out_channels, kernel_size=3) + + self.gradient_checkpointing = False + + def forward( + self, + sample: torch.FloatTensor, + latent_embeds: Optional[torch.FloatTensor] = None, + ) -> torch.FloatTensor: + r"""The forward method of the `DecoderCausal3D` class.""" + assert len(sample.shape) == 5, "The input tensor should have 5 dimensions." + + sample = self.conv_in(sample) + + upscale_dtype = next(iter(self.up_blocks.parameters())).dtype + if self.training and self.gradient_checkpointing: + + def create_custom_forward(module): + def custom_forward(*inputs): + return module(*inputs) + + return custom_forward + + if is_torch_version(">=", "1.11.0"): + # middle + sample = torch.utils.checkpoint.checkpoint( + create_custom_forward(self.mid_block), + sample, + latent_embeds, + use_reentrant=False, + ) + sample = sample.to(upscale_dtype) + + # up + for up_block in self.up_blocks: + sample = torch.utils.checkpoint.checkpoint( + create_custom_forward(up_block), + sample, + latent_embeds, + use_reentrant=False, + ) + else: + # middle + sample = torch.utils.checkpoint.checkpoint(create_custom_forward(self.mid_block), sample, latent_embeds) + sample = sample.to(upscale_dtype) + + # up + for up_block in self.up_blocks: + sample = torch.utils.checkpoint.checkpoint(create_custom_forward(up_block), sample, latent_embeds) + else: + # middle + sample = self.mid_block(sample, latent_embeds) + sample = sample.to(upscale_dtype) + + # up + for up_block in self.up_blocks: + sample = up_block(sample, latent_embeds) + + # post-process + if latent_embeds is None: + sample = self.conv_norm_out(sample) + else: + sample = self.conv_norm_out(sample, latent_embeds) + sample = self.conv_act(sample) + sample = self.conv_out(sample) + + return sample + + +class DiagonalGaussianDistribution(object): + def __init__(self, parameters: torch.Tensor, deterministic: bool = False): + if parameters.ndim == 3: + dim = 2 # (B, L, C) + elif parameters.ndim == 5 or parameters.ndim == 4: + dim = 1 # (B, C, T, H ,W) / (B, C, H, W) + else: + raise NotImplementedError + self.parameters = parameters + self.mean, self.logvar = torch.chunk(parameters, 2, dim=dim) + self.logvar = torch.clamp(self.logvar, -30.0, 20.0) + self.deterministic = deterministic + self.std = torch.exp(0.5 * self.logvar) + self.var = torch.exp(self.logvar) + if self.deterministic: + self.var = self.std = torch.zeros_like(self.mean, device=self.parameters.device, dtype=self.parameters.dtype) + + def sample(self, generator: Optional[torch.Generator] = None) -> torch.FloatTensor: + # make sure sample is on the same device as the parameters and has same dtype + sample = randn_tensor( + self.mean.shape, + generator=generator, + device=self.parameters.device, + dtype=self.parameters.dtype, + ) + x = self.mean + self.std * sample + return x + + def kl(self, other: "DiagonalGaussianDistribution" = None) -> torch.Tensor: + if self.deterministic: + return torch.Tensor([0.0]) + else: + reduce_dim = list(range(1, self.mean.ndim)) + if other is None: + return 0.5 * torch.sum( + torch.pow(self.mean, 2) + self.var - 1.0 - self.logvar, + dim=reduce_dim, + ) + else: + return 0.5 * torch.sum( + torch.pow(self.mean - other.mean, 2) / other.var + self.var / other.var - 1.0 - self.logvar + other.logvar, + dim=reduce_dim, + ) + + def nll(self, sample: torch.Tensor, dims: Tuple[int, ...] = [1, 2, 3]) -> torch.Tensor: + if self.deterministic: + return torch.Tensor([0.0]) + logtwopi = np.log(2.0 * np.pi) + return 0.5 * torch.sum( + logtwopi + self.logvar + torch.pow(sample - self.mean, 2) / self.var, + dim=dims, + ) + + def mode(self) -> torch.Tensor: + return self.mean diff --git a/src/musubi_tuner/hunyuan_video_1_5/hunyuan_video_1_5_models.py b/src/musubi_tuner/hunyuan_video_1_5/hunyuan_video_1_5_models.py new file mode 100644 index 0000000000000000000000000000000000000000..f5959c582b569a13745de730c6cb4b3cca6d3fea --- /dev/null +++ b/src/musubi_tuner/hunyuan_video_1_5/hunyuan_video_1_5_models.py @@ -0,0 +1,500 @@ +# Original work: https://github.com/Tencent-Hunyuan/HunyuanVideo-1.5 +# Re-implemented for license compliance for sd-scripts. + +from typing import Dict, Optional, Tuple, Union + +import torch +import torch.nn as nn +from accelerate import init_empty_weights + +import logging + +from musubi_tuner.modules.attention import AttentionParams +from musubi_tuner.modules.custom_offloading_utils import ModelOffloader +from musubi_tuner.modules.fp8_optimization_utils import apply_fp8_monkey_patch +from musubi_tuner.utils.lora_utils import load_safetensors_with_lora_and_fp8 +from musubi_tuner.utils.safetensors_utils import MemoryEfficientSafeOpen, WeightTransformHooks + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +from musubi_tuner.hunyuan_video_1_5.hunyuan_video_1_5_modules import ( + PatchEmbed, + SingleTokenRefiner, + ByT5Mapper, + TimestepEmbedder, + MMDoubleStreamBlock, + FinalLayer, + VisionProjection, +) +from musubi_tuner.hunyuan_video_1_5.hunyuan_video_1_5_utils import get_nd_rotary_pos_embed + +FP8_OPTIMIZATION_TARGET_KEYS = ["double_blocks"] +# FP8_OPTIMIZATION_EXCLUDE_KEYS = ["norm", "_mod", "_emb"] # , "modulation" +FP8_OPTIMIZATION_EXCLUDE_KEYS = ["norm", "_emb"] # , "modulation", "_mod" + + +# region DiT Model +class HunyuanVideo_1_5_DiffusionTransformer(nn.Module): + """ + HunyuanVideo-1.5 Diffusion Transformer. + + A multimodal transformer for image generation with text conditioning, + featuring separate double-stream and single-stream processing blocks. + + Args: + attn_mode: Attention implementation mode. + """ + + def __init__(self, task_type: str = "t2v", attn_mode: str = "torch", split_attn: bool = False): + super().__init__() + assert task_type in ["t2v", "i2v"], f"Unsupported task type: {task_type}" + self.task_type = task_type + + # Fixed architecture parameters for HunyuanVideo-1.5 + self.patch_size = [1, 1, 1] # 1x1 patch size (no spatial downsampling) + self.in_channels = 32 # Input latent channels + self.out_channels = 32 # Output latent channels + self.unpatchify_channels = self.out_channels + self.guidance_embed = False # Guidance embedding disabled + self.rope_dim_list = [16, 56, 56] # RoPE dimensions for 2D positional encoding + self.rope_theta = 256 # RoPE frequency scaling + self.use_attention_mask = True + self.vision_projection = "linear" + self.vision_states_dim = 1152 + self.text_projection = "single_refiner" + self.hidden_size = 2048 # Model dimension + self.heads_num = 16 # Number of attention heads + + # Architecture configuration + mm_double_blocks_depth = 54 # Double-stream transformer blocks + # mm_single_blocks_depth = 0 # Single-stream transformer blocks + mlp_width_ratio = 4 # MLP expansion ratio + text_states_dim = 3584 # Text encoder output dimension + guidance_embed = False # No guidance embedding + + # Layer configuration + mlp_act_type: str = "gelu_tanh" # MLP activation function + qkv_bias: bool = True # Use bias in QKV projections + qk_norm: bool = True # Apply QK normalization + qk_norm_type: str = "rms" # RMS normalization type + + self.attn_mode = attn_mode + self.split_attn = split_attn + + # ByT5 character-level text encoder mapping + self.byt5_in = ByT5Mapper(in_dim=1472, out_dim=2048, hidden_dim=2048, out_dim1=self.hidden_size, use_residual=False) + + # Image latent patch embedding + self.img_in = PatchEmbed(self.patch_size, self.in_channels, self.hidden_size) + + # Vision feature projection + self.vision_in = VisionProjection(input_dim=self.vision_states_dim, output_dim=self.hidden_size) + + # Text token refinement with cross-attention + self.txt_in = SingleTokenRefiner(text_states_dim, self.hidden_size, self.heads_num, depth=2) + + # Timestep embedding for diffusion process + self.time_in = TimestepEmbedder(self.hidden_size, nn.SiLU) + + # MeanFlow not supported in this implementation + self.time_r_in = None + + # Guidance embedding (disabled for non-distilled model) + self.guidance_in = TimestepEmbedder(self.hidden_size, nn.SiLU) if guidance_embed else None + + # Double-stream blocks: separate image and text processing + self.double_blocks = nn.ModuleList( + [ + MMDoubleStreamBlock( + self.hidden_size, + self.heads_num, + mlp_width_ratio=mlp_width_ratio, + mlp_act_type=mlp_act_type, + qk_norm=qk_norm, + qk_norm_type=qk_norm_type, + qkv_bias=qkv_bias, + ) + for _ in range(mm_double_blocks_depth) + ] + ) + + self.final_layer = FinalLayer(self.hidden_size, self.patch_size, self.out_channels, nn.SiLU) + + self.cond_type_embedding = nn.Embedding(3, self.hidden_size) + + self.gradient_checkpointing = False + self.cpu_offload_checkpointing = False + self.blocks_to_swap = None + + self.offloader_double = None + self.num_double_blocks = len(self.double_blocks) + + @property + def device(self): + return next(self.parameters()).device + + @property + def dtype(self): + return next(self.parameters()).dtype + + def enable_gradient_checkpointing(self, cpu_offload: bool = False): + self.gradient_checkpointing = True + self.cpu_offload_checkpointing = cpu_offload + + for block in self.double_blocks: + block.enable_gradient_checkpointing(cpu_offload=cpu_offload) + + print(f"HunyuanVideo-1.5: Gradient checkpointing enabled. CPU offload: {cpu_offload}") + + def disable_gradient_checkpointing(self): + self.gradient_checkpointing = False + self.cpu_offload_checkpointing = False + + for block in self.double_blocks: + block.disable_gradient_checkpointing() + + print("HunyuanVideo-1.5: Gradient checkpointing disabled.") + + def enable_block_swap(self, num_blocks: int, device: torch.device, supports_backward: bool, use_pinned_memory: bool = False): + self.blocks_to_swap = num_blocks + + assert self.blocks_to_swap < self.num_double_blocks - 2, ( + f"Cannot swap more than {self.num_double_blocks - 2} double blocks. Requested {self.blocks_to_swap} double blocks." + ) + + self.offloader_double = ModelOffloader( + "double", self.double_blocks, len(self.double_blocks), self.blocks_to_swap, supports_backward, device, use_pinned_memory + ) + print( + f"HunyuanVideo-1.5: Block swap enabled. Swapping {num_blocks} blocks to device {device}. Supports backward: {supports_backward}" + ) + + def switch_block_swap_for_inference(self): + if self.blocks_to_swap: + self.offloader_double.set_forward_only(True) + self.prepare_block_swap_before_forward() + print("HunyuanVideo-1.5: Block swap set to forward only.") + + def switch_block_swap_for_training(self): + if self.blocks_to_swap: + self.offloader_double.set_forward_only(False) + self.prepare_block_swap_before_forward() + print("HunyuanVideo-1.5: Block swap set to forward and backward.") + + def move_to_device_except_swap_blocks(self, device: torch.device): + # assume model is on cpu. do not move blocks to device to reduce temporary memory usage + if self.blocks_to_swap: + save_double_blocks = self.double_blocks + self.double_blocks = nn.ModuleList() + + self.to(device) + + if self.blocks_to_swap: + self.double_blocks = save_double_blocks + + def prepare_block_swap_before_forward(self): + if self.blocks_to_swap is None or self.blocks_to_swap == 0: + return + self.offloader_double.prepare_block_devices_before_forward(self.double_blocks) + + def get_rotary_pos_embed(self, rope_sizes): + """ + Generate 3D rotary position embeddings for image tokens. + + Args: + rope_sizes: Tuple of (height, width) for spatial dimensions. + + Returns: + Tuple of (freqs_cos, freqs_sin) tensors for rotary position encoding. + """ + freqs_cos, freqs_sin = get_nd_rotary_pos_embed(self.rope_dim_list, rope_sizes, theta=self.rope_theta) + return freqs_cos, freqs_sin + + def forward( + self, + hidden_states: torch.Tensor, + timestep: torch.LongTensor, + text_states: torch.Tensor, + encoder_attention_mask: torch.Tensor, + vision_states: Optional[torch.Tensor] = None, + byt5_text_states: Optional[torch.Tensor] = None, + byt5_text_mask: Optional[torch.Tensor] = None, + rotary_pos_emb_cache: Optional[Dict[Tuple[int, int, int], Tuple[torch.Tensor, torch.Tensor]]] = None, + ) -> torch.Tensor: + """ + Forward pass through the HunyuanVideo diffusion transformer. + + Args: + hidden_states: Input image latents [B, C, H, W]. + timestep: Diffusion timestep [B]. + text_states: Word-level text embeddings [B, L, D]. + encoder_attention_mask: Text attention mask [B, L]. + byt5_text_states: ByT5 character-level embeddings [B, L_byt5, D_byt5]. + byt5_text_mask: ByT5 attention mask [B, L_byt5]. + + Returns: + Tuple of (denoised_image, spatial_shape). + """ + bs = hidden_states.shape[0] + img = x = hidden_states + text_mask = encoder_attention_mask + t = timestep + txt = text_states + + # Calculate spatial dimensions for rotary position embeddings + _, _, ot, oh, ow = x.shape + tt, th, tw = ot, oh, ow # frame, height and width (patch_size=[1,1,1] means no temporal and spatial downsampling) + if rotary_pos_emb_cache is not None: + if (th, th, tw) in rotary_pos_emb_cache: + freqs_cis = rotary_pos_emb_cache[(tt, th, tw)] + freqs_cis = (freqs_cis[0].to(img.device), freqs_cis[1].to(img.device)) + else: + freqs_cis = self.get_rotary_pos_embed((tt, th, tw)) + rotary_pos_emb_cache[(tt, th, tw)] = (freqs_cis[0].cpu(), freqs_cis[1].cpu()) + else: + freqs_cis = self.get_rotary_pos_embed((tt, th, tw)) + + # Reshape image latents to sequence format: [B, C, H, W] -> [B, H*W, C] + img = self.img_in(img) + + # Generate timestep conditioning vector + vec = self.time_in(t) + + # MeanFlow and guidance embedding not used in this configuration + + # Process text tokens through refinement layers + txt_attn_params = AttentionParams.create_attention_params_from_mask(self.attn_mode, self.split_attn, 0, text_mask) + txt = self.txt_in(txt, t, txt_attn_params) + + cond_emb = self.cond_type_embedding(torch.zeros_like(txt[:, :, 0], device=txt.device, dtype=torch.long)) + txt = txt + cond_emb + + # Process ByT5 character-level text embeddings if provided + byt5_txt = self.byt5_in(byt5_text_states) + + cond_emb = self.cond_type_embedding(torch.ones_like(byt5_txt[:, :, 0], device=byt5_txt.device, dtype=torch.long)) + byt5_txt = byt5_txt + cond_emb + + # Project vision features if provided + if vision_states is not None: + if self.task_type == "t2v" and torch.all(vision_states == 0): + # This does not affect the output because of the masks. Kept for reference. + # # If t2v, set extra_attention_mask to zeros when vision_states is all zeros + # extra_attention_mask = torch.zeros( + # bs, extra_encoder_hidden_states.shape[1], device=text_mask.device, dtype=text_mask.dtype + # ) + # # Original impl comment: Set vision tokens to zero to mitigate potential block mask error in SSTA + # extra_encoder_hidden_states = extra_encoder_hidden_states * 0 + vision_states = None + else: + extra_encoder_hidden_states = self.vision_in(vision_states) + cond_emb = self.cond_type_embedding( + torch.full_like( + extra_encoder_hidden_states[:, :, 0], 2, device=extra_encoder_hidden_states.device, dtype=torch.long + ) + ) + extra_encoder_hidden_states = extra_encoder_hidden_states + cond_emb + else: + extra_encoder_hidden_states = None + + # concatenate txt tokens in the order of [vision (if any), ByT5, word tokens] + concatenated_txt = [] + txt_lens = [] + for i in range(bs): + txt_length = text_mask[i].to(dtype=torch.bool).sum() + byt5_txt_length = byt5_text_mask[i].to(dtype=torch.bool).sum() + total_length = txt_length + byt5_txt_length + + txt_i = txt[i, :txt_length, :] + byt5_txt_i = byt5_txt[i, :byt5_txt_length, :] + + if vision_states is not None: + extra_encoder_hidden_states_i = extra_encoder_hidden_states[i] + concatenated_txt_i = torch.cat([extra_encoder_hidden_states_i, byt5_txt_i, txt_i], dim=0) + total_length += extra_encoder_hidden_states_i.shape[0] + else: + concatenated_txt_i = torch.cat([byt5_txt_i, txt_i], dim=0) + + concatenated_txt.append(concatenated_txt_i) + txt_lens.append(total_length) + + # pad to max length in the batch + max_txt_len = max(txt_lens) + txt = torch.stack( + [ + torch.cat( + [concatenated_txt[i], torch.zeros(max_txt_len - txt_lens[i], concatenated_txt[i].shape[-1], device=txt.device)] + ) + for i in range(bs) + ] + ) + + # create combined text mask + if bs == 1: + text_mask = None # for single batch, no need to pass mask + else: + text_mask = torch.stack( + [ + torch.cat( + [ + torch.ones(txt_lens[i], device=text_mask.device, dtype=text_mask.dtype), + torch.zeros(max_txt_len - txt_lens[i], device=text_mask.device, dtype=text_mask.dtype), + ] + ) + for i in range(bs) + ] + ) + img_seq_len = img.shape[1] + + attn_params = AttentionParams.create_attention_params_from_mask(self.attn_mode, self.split_attn, img_seq_len, text_mask) + + # Process through double-stream blocks (separate image/text attention) + for index, block in enumerate(self.double_blocks): + if self.blocks_to_swap: + self.offloader_double.wait_for_block(index) + img, txt = block(img, txt, vec, freqs_cis, attn_params) + if self.blocks_to_swap: + self.offloader_double.submit_move_blocks_forward(self.double_blocks, index) + del txt, attn_params, freqs_cis + + # Apply final projection to output space + img = self.final_layer(img, vec) + del vec + + # Reshape from sequence to spatial format: [B, L, C] -> [B, C, T, H, W] + img = self.unpatchify(img, tt, th, tw) + return img + + def unpatchify(self, x, t, h, w): + """ + Convert sequence format back to spatial image format. + + Args: + x: Input tensor [B, T*H*W, C]. + h: Height dimension. + w: Width dimension. + + Returns: + Spatial tensor [B, C, T, H, W]. + """ + c = self.unpatchify_channels + + x = x.reshape(shape=(x.shape[0], t, h, w, c)) + imgs = x.permute(0, 4, 1, 2, 3) # .contiguous() + return imgs + + +# endregion + +# region Model Utils + + +def detect_hunyuan_video_1_5_sd_dtype(path: str) -> torch.dtype: + # get dtype from model weights + with MemoryEfficientSafeOpen(path) as f: + keys = set(f.keys()) + key1 = "double_blocks.0.img_attn_k.weight" # Official + key2 = "double_blocks.0.img_attn_qkv.weight" # ComfyUI repackaged + if key1 in keys: + dit_dtype = f.get_tensor(key1).dtype + elif key2 in keys: + dit_dtype = f.get_tensor(key2).dtype + else: + raise ValueError(f"Could not find the dtype in the model weights: {path}") + logger.info(f"Detected DiT dtype: {dit_dtype}") + return dit_dtype + + +def create_model( + task_type: str, attn_mode: str, split_attn: bool, dtype: Optional[torch.dtype] +) -> HunyuanVideo_1_5_DiffusionTransformer: + with init_empty_weights(): + model = HunyuanVideo_1_5_DiffusionTransformer(task_type=task_type, attn_mode=attn_mode, split_attn=split_attn) + if dtype is not None: + model.to(dtype) + return model + + +def load_hunyuan_video_1_5_model( + device: Union[str, torch.device], + task_type: str, + dit_path: str, + attn_mode: str, + split_attn: bool, + loading_device: Union[str, torch.device], + dit_weight_dtype: Optional[torch.dtype], + fp8_scaled: bool = False, + lora_weights_list: Optional[Dict[str, torch.Tensor]] = None, + lora_multipliers: Optional[list[float]] = None, +) -> HunyuanVideo_1_5_DiffusionTransformer: + """ + Load a HunyuanVideo model from the specified checkpoint. + + Args: + device (Union[str, torch.device]): Device for optimization or merging + task_type (str): Task type, either "t2v" or "i2v". + dit_path (str): Path to the DiT model checkpoint. + attn_mode (str): Attention mode to use, e.g., "torch", "flash", etc. + split_attn (bool): Whether to use split attention. + loading_device (Union[str, torch.device]): Device to load the model weights on. + dit_weight_dtype (Optional[torch.dtype]): Data type of the DiT weights. + If None, it will be loaded as is (same as the state_dict) or scaled for fp8. if not None, model weights will be casted to this dtype. + fp8_scaled (bool): Whether to use fp8 scaling for the model weights. + lora_weights_list (Optional[Dict[str, torch.Tensor]]): LoRA weights to apply, if any. + lora_multipliers (Optional[List[float]]): LoRA multipliers for the weights, if any. + """ + # dit_weight_dtype is None for fp8_scaled + assert (not fp8_scaled and dit_weight_dtype is not None) or (fp8_scaled and dit_weight_dtype is None) + + device = torch.device(device) + loading_device = torch.device(loading_device) + + model = create_model(task_type, attn_mode, split_attn, dit_weight_dtype) + + # load model weights with dynamic fp8 optimization and LoRA merging if needed + logger.info(f"Loading DiT model from {dit_path}, device={loading_device}") + + def comfyui_hunyuan_video_1_5_weight_split_hook( + key: str, value: Optional[torch.Tensor] + ) -> Tuple[Optional[list[str]], Optional[list[torch.Tensor]]]: + # ComfyUI repackaged HunyuanVideo-1.5 uses packed QKV weights for double blocks + if "img_attn_qkv.weight" in key or "img_attn_qkv.bias" in key or "txt_attn_qkv.weight" in key or "txt_attn_qkv.bias" in key: + # convert to separate Q, K, V weights/biases + new_keys = [key.replace("_qkv", suffix) for suffix in ["_q", "_k", "_v"]] + return new_keys, list(torch.chunk(value, 3, dim=0)) if value is not None else None + + return None, None + + hooks = WeightTransformHooks(split_hook=comfyui_hunyuan_video_1_5_weight_split_hook, concat_hook=None) + + sd = load_safetensors_with_lora_and_fp8( + model_files=dit_path, + lora_weights_list=lora_weights_list, + lora_multipliers=lora_multipliers, + fp8_optimization=fp8_scaled, + calc_device=device, + move_to_device=(loading_device == device), + dit_weight_dtype=dit_weight_dtype, + target_keys=FP8_OPTIMIZATION_TARGET_KEYS, + exclude_keys=FP8_OPTIMIZATION_EXCLUDE_KEYS, + weight_transform_hooks=hooks, + ) + + if fp8_scaled: + apply_fp8_monkey_patch(model, sd, use_scaled_mm=False) + + if loading_device.type != "cpu": + # make sure all the model weights are on the loading_device + logger.info(f"Moving weights to {loading_device}") + for key in sd.keys(): + sd[key] = sd[key].to(loading_device) + + info = model.load_state_dict(sd, strict=True, assign=True) + logger.info(f"Loaded DiT model from {dit_path}, info={info}") + + return model + + +# endregion diff --git a/src/musubi_tuner/kandinsky5/__init__.py b/src/musubi_tuner/kandinsky5/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/musubi_tuner/ltx_2/__init__.py b/src/musubi_tuner/ltx_2/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/musubi_tuner/ltx_2/env.py b/src/musubi_tuner/ltx_2/env.py new file mode 100644 index 0000000000000000000000000000000000000000..9915cacdba8ad640ef692cea0fd80b4a2fb743d7 --- /dev/null +++ b/src/musubi_tuner/ltx_2/env.py @@ -0,0 +1,343 @@ +from __future__ import annotations + +import os +from dataclasses import dataclass + +from musubi_tuner.ltx_2.model.ltx2_custom_offloading_utils import ( + set_fp8_offload_keep_fp8, + set_fp8_offload_restore_bf16, + set_fp8_offload_restore_stochastic, + set_fp8_offload_upcast, +) + + +@dataclass(frozen=True) +class LTX2Env: + # Apply audio_lengths mask to audio loss. + # recommended=True + use_audio_length_mask: bool = True + + # Upcast FP8 Linear weights to compute dtype during forward for stability. + # recommended=True + fp8_upcast: bool = False + + # Add stochastic rounding during FP8 upcast (extra stability, more noise). + # recommended=False + fp8_upcast_stochastic: bool = False + + # Seed for stochastic FP8 upcast (only used if fp8_upcast_stochastic=True). + # recommended=0 + fp8_upcast_seed: int = 0 + + # Allow FP8 weights to be offloaded to CPU by upcasting to bf16. + # recommended=True + fp8_offload_upcast: bool = False + + # Keep FP8-offloaded weights in bf16 on GPU after restore (avoid FP8 round-trip). + # recommended=True + fp8_offload_restore_bf16: bool = False + + # Keep FP8 weights in FP8 on CPU (avoid bf16 upcast and GPU re-cast cost). + # recommended=False + fp8_offload_keep_fp8: bool = False + + # Allow FP8 CPU offload only when blockwise checkpointing is enabled. + # recommended=False + blockwise_fp8_offload_upcast: bool = True + + # Add stochastic noise before restoring FP8 weights (experimental). + # recommended=False + fp8_offload_restore_stochastic: bool = False + + # Keep attention weights on GPU during block swap (stability, higher VRAM). + # recommended=True + swap_keep_attn: bool = False + + # Keep cross-attn weights on GPU during swap (stability). + # recommended=True + swap_keep_cross_attn: bool = False + + # Keep audio-related weights on GPU during swap (stability). + # recommended=True + swap_keep_audio: bool = False + + # Force PyTorch attention for audio ctx + cross-attn in swapped blocks. + # recommended=True + attn_stability: bool = False + + # Force FP32 attention for audio ctx + cross-attn in swapped blocks. + # recommended=False + attn_stability_fp32: bool = False + + # Keep prompt-AdaLN modulation in float32 for consistency with the other + # AdaLN stability fixes. + # recommended=True + prompt_adaln_fp32: bool = True + + # Combined safe swap attention preset (keep attn + PyTorch + FP32 retry). + # recommended=True + safe_swap_attn: bool = False + + # FP8 swap safety preset (strict sync + safe swap attn). + # recommended=True + fp8_swap_safe: bool = True + + # Ensure FP8 weights are on device after swap-in. + # recommended=True + swap_fp8_sync: bool = False + + # Strict CUDA sync after FP8 swap-in. + # recommended=False + swap_fp8_sync_strict: bool = True + + # Force PyTorch attention for swapped blocks. + # recommended=False + swap_force_pytorch_attn: bool = False + + # Retry attention in FP32 if non-finite detected. + # recommended=True + attn_fp32_retry: bool = False + + # Force PyTorch attention for audio context. + # recommended=False + force_pytorch_audio_ctx_attn: bool = False + + # Force FP32 for audio context attention. + # recommended=False + audio_ctx_attn_fp32: bool = False + + # Force PyTorch for cross-attn. + # recommended=False + force_pytorch_cross_attn: bool = False + + # Force FP32 for cross-attn. + # recommended=False + cross_attn_fp32: bool = False + + # Apply cross-attn forcing only in swapped blocks. + # recommended=True + cross_attn_swap_only: bool = True + + # Apply audio-ctx forcing only in swapped blocks. + # recommended=True + audio_ctx_attn_swap_only: bool = True + + # Async prefetch stream for swap (faster but can be unstable). + # recommended=False + swap_async_prefetch: bool = False + + # Pinned memory for swap/offload (faster, can destabilize). + # recommended=False + swap_pinned: bool = False + + # Swap RMSNorm/LayerNorm weights to CPU during block swap (VRAM saver). + # recommended=False + swap_norms: bool = False + + # Log sublayer-level non-finite diagnostics. + # recommended=False + nan_sublayer_diag: bool = False + + # Log block-level non-finite diagnostics. + # recommended=False + nan_block_diag: bool = False + + # Log NaN debug stats (latents/text/etc). + # recommended=False + nan_diag: bool = False + + # Trainer loss diagnostics (LTX2_LOSS_DIAG / LTX2_LOSS_DIAG_EVERY). + # recommended=False + loss_diag: bool = False + + # Frequency for loss diagnostics. + # recommended=10 + loss_diag_every: int = 10 + + # Swap/offloader diagnostics. + # recommended=False + swap_diag: bool = False + + # Offloader debug prints (LTX2_OFFLOADER_DEBUG). + # recommended=False + offloader_debug: bool = False + + # Extra debug flag used by hv_train_network (LTX2_DEBUG). + # recommended=False + debug: bool = False + + # Log V2A (video-to-audio) internal stats. + # recommended=False + v2a_diag: bool = False + + # Align audio latents to video duration during training. + # recommended=False + align_audio_latents_train: bool = False + + # Align audio latents to video duration during cache_latents. + # recommended=False + align_audio_latents_cache: bool = False + + # Use video_prompt_embeds as AV fallback when audio missing. + # recommended=False + av_use_video_prompt_embeds: bool = False + + # Use 5D video loss mask (broadcast-friendly). + # recommended=False + video_loss_mask_5d: bool = False + + # Align transformer outputs to proj_out device. + # recommended=False + align_output_device: bool = False + + # Skip steps on non-finite tensors instead of erroring. + # recommended=False + skip_nonfinite_steps: bool = True + + # Auto-set blocks_to_checkpoint when blockwise+swap are both enabled. + # recommended=False + auto_blocks_to_checkpoint: bool = False + + # Require gemma_root (no gemma_safetensors-only usage). + # recommended=True + require_gemma_root: bool = True + + # Skip no-op attention masks to enable Flash Attention on cross-attn. + # recommended=False + skip_noop_attn_mask: bool = False + + # Max FPS difference (after ceiling source FPS) below which resampling is skipped. + # e.g. threshold=1: 23.976->ceil=24 vs 25, diff=1, skip. 30 vs 25, diff=5, resample. + # recommended=1 + fps_resampling_threshold: int = 1 + + # Number of blocks to prefetch ahead during block swap (1 = current behavior). + # Higher values overlap more transfers with compute but use more VRAM. + # recommended=1 + swap_prefetch_window: int = 1 + + # Use pre-allocated pinned slab pool instead of lazy per-parameter _pinned_buffer_cache. + # recommended=False + swap_slab_pool: bool = False + + +DEFAULT_ENV = LTX2Env() + + +def _set_env_bool(key: str, enabled: bool) -> None: + os.environ[key] = "1" if enabled else "0" + + +def get_ltx2_env() -> LTX2Env: + return DEFAULT_ENV + + +def apply_ltx2_tweaks(args) -> None: + t = DEFAULT_ENV + + args.use_audio_length_mask = t.use_audio_length_mask + + args.fp8_upcast = t.fp8_upcast + args.fp8_upcast_stochastic = t.fp8_upcast_stochastic + args.fp8_upcast_seed = int(t.fp8_upcast_seed) + + args.fp8_offload_upcast = t.fp8_offload_upcast + args.fp8_offload_restore_bf16 = t.fp8_offload_restore_bf16 + args.fp8_offload_restore_stochastic = t.fp8_offload_restore_stochastic + args.fp8_offload_keep_fp8 = t.fp8_offload_keep_fp8 + + args.swap_keep_attn = t.swap_keep_attn + args.swap_keep_cross_attn = t.swap_keep_cross_attn + args.swap_keep_audio = t.swap_keep_audio + args.attn_stability = t.attn_stability + args.attn_stability_fp32 = t.attn_stability_fp32 + args.prompt_adaln_fp32 = t.prompt_adaln_fp32 + args.safe_swap_attn = t.safe_swap_attn + args.fp8_swap_safe = t.fp8_swap_safe + args.swap_fp8_sync = t.swap_fp8_sync + args.swap_fp8_sync_strict = t.swap_fp8_sync_strict + args.swap_force_pytorch_attn = t.swap_force_pytorch_attn + args.attn_fp32_retry = t.attn_fp32_retry + args.force_pytorch_audio_ctx_attn = t.force_pytorch_audio_ctx_attn + args.audio_ctx_attn_fp32 = t.audio_ctx_attn_fp32 + args.force_pytorch_cross_attn = t.force_pytorch_cross_attn + args.cross_attn_fp32 = t.cross_attn_fp32 + args.cross_attn_swap_only = t.cross_attn_swap_only + args.audio_ctx_attn_swap_only = t.audio_ctx_attn_swap_only + + args.swap_async_prefetch = t.swap_async_prefetch + args.swap_no_async_prefetch = not t.swap_async_prefetch + cli_swap_pinned = bool(getattr(args, "use_pinned_memory_for_block_swap", False)) + effective_swap_pinned = bool(t.swap_pinned or cli_swap_pinned) + args.swap_pinned = effective_swap_pinned + args.swap_no_pinned = not effective_swap_pinned + args.swap_norms = t.swap_norms + + args.nan_sublayer_diag = t.nan_sublayer_diag + args.nan_block_diag = t.nan_block_diag + + args.align_audio_latents_train = t.align_audio_latents_train + args.align_audio_latents_cache = t.align_audio_latents_cache + args.av_use_video_prompt_embeds = t.av_use_video_prompt_embeds + args.video_loss_mask_5d = t.video_loss_mask_5d + args.align_output_device = t.align_output_device + args.skip_nonfinite_steps = t.skip_nonfinite_steps + args.auto_blocks_to_checkpoint = t.auto_blocks_to_checkpoint + args.require_gemma_root = t.require_gemma_root + args.skip_noop_attn_mask = t.skip_noop_attn_mask + + # Apply global FP8 offload behavior. + fp8_offload_enabled = t.fp8_offload_upcast + if ( + getattr(args, "blockwise_checkpointing", False) + and t.blockwise_fp8_offload_upcast + ): + fp8_offload_enabled = True + set_fp8_offload_upcast(fp8_offload_enabled) + set_fp8_offload_restore_bf16(t.fp8_offload_restore_bf16) + set_fp8_offload_restore_stochastic(t.fp8_offload_restore_stochastic) + set_fp8_offload_keep_fp8(t.fp8_offload_keep_fp8) + + # Apply env vars consumed in transformer/offloading code. + _set_env_bool("LTX2_SWAP_KEEP_ATTN", t.swap_keep_attn) + _set_env_bool("LTX2_SWAP_KEEP_CROSS_ATTN", t.swap_keep_cross_attn) + _set_env_bool("LTX2_SWAP_SKIP_AUDIO", t.swap_keep_audio) + _set_env_bool("LTX2_SWAP_ASYNC_PREFETCH", t.swap_async_prefetch) + _set_env_bool("LTX2_SWAP_PINNED", effective_swap_pinned) + _set_env_bool("LTX2_SWAP_FP8_SYNC", t.swap_fp8_sync) + _set_env_bool("LTX2_SWAP_FP8_SYNC_STRICT", t.swap_fp8_sync_strict) + _set_env_bool("LTX2_FP8_OFFLOAD_KEEP_FP8", t.fp8_offload_keep_fp8) + _set_env_bool("LTX2_SWAP_STRICT_SYNC", t.fp8_swap_safe) + _set_env_bool("LTX2_SWAP_FORCE_PYTORCH_ATTN", t.swap_force_pytorch_attn) + _set_env_bool( + "LTX2_FORCE_PYTORCH_AUDIO_CTX_ATTN", + t.force_pytorch_audio_ctx_attn or t.attn_stability or t.safe_swap_attn, + ) + _set_env_bool( + "LTX2_AUDIO_CTX_ATTN_FP32", t.audio_ctx_attn_fp32 or t.attn_stability_fp32 + ) + _set_env_bool( + "LTX2_FORCE_PYTORCH_CROSS_ATTN", + t.force_pytorch_cross_attn or t.attn_stability or t.safe_swap_attn, + ) + _set_env_bool("LTX2_CROSS_ATTN_FP32", t.cross_attn_fp32 or t.attn_stability_fp32) + _set_env_bool("LTX2_PROMPT_ADALN_FP32", t.prompt_adaln_fp32) + _set_env_bool("LTX2_CROSS_ATTN_SWAP_ONLY", t.cross_attn_swap_only) + _set_env_bool("LTX2_AUDIO_CTX_ATTN_SWAP_ONLY", t.audio_ctx_attn_swap_only) + _set_env_bool( + "LTX2_ATTN_FP32_RETRY", t.attn_fp32_retry or t.safe_swap_attn or t.fp8_swap_safe + ) + _set_env_bool("LTX2_NAN_SUBLAYER_DIAG", t.nan_sublayer_diag) + _set_env_bool("LTX2_NAN_BLOCK_DIAG", t.nan_block_diag) + _set_env_bool("LTX2_NAN_DIAG", t.nan_diag) + _set_env_bool("LTX2_LOSS_DIAG", t.loss_diag) + os.environ["LTX2_LOSS_DIAG_EVERY"] = str(int(t.loss_diag_every)) + _set_env_bool("LTX2_SWAP_DIAG", t.swap_diag) + _set_env_bool("LTX2_OFFLOADER_DEBUG", t.offloader_debug) + _set_env_bool("LTX2_DEBUG", t.debug) + _set_env_bool("LTX2_V2A_DIAG", t.v2a_diag) + _set_env_bool("LTX2_ALIGN_OUTPUT_DEVICE", t.align_output_device) + _set_env_bool("LTX2_REQUIRE_GEMMA_ROOT", t.require_gemma_root) + _set_env_bool("LTX2_SKIP_NOOP_ATTN_MASK", t.skip_noop_attn_mask) + os.environ["LTX2_SWAP_PREFETCH_WINDOW"] = str(int(t.swap_prefetch_window)) + _set_env_bool("LTX2_SWAP_SLAB_POOL", t.swap_slab_pool) diff --git a/src/musubi_tuner/ltx_2/tools.py b/src/musubi_tuner/ltx_2/tools.py new file mode 100644 index 0000000000000000000000000000000000000000..c4ffb04a73efb2f9f4ec0ca4d43726c7db521c01 --- /dev/null +++ b/src/musubi_tuner/ltx_2/tools.py @@ -0,0 +1,183 @@ +from dataclasses import dataclass, replace +from typing import Protocol + +import torch +from torch._prims_common import DeviceLikeType +from musubi_tuner.ltx_2.components.patchifiers import ( + AudioLatentShape, + AudioPatchifier, + VideoLatentPatchifier, + VideoLatentShape, + get_pixel_coords, +) +from musubi_tuner.ltx_2.components.protocols import Patchifier +from musubi_tuner.ltx_2.types import LatentState, SpatioTemporalScaleFactors + +DEFAULT_SCALE_FACTORS = SpatioTemporalScaleFactors.default() + + +class LatentTools(Protocol): + """ + Tools for building latent states. + """ + + patchifier: Patchifier + target_shape: VideoLatentShape | AudioLatentShape + + def create_initial_state( + self, + device: DeviceLikeType, + dtype: torch.dtype, + initial_latent: torch.Tensor | None = None, + ) -> LatentState: + """ + Create an initial latent state. If initial_latent is provided, it will be used to create the latent state. + """ + ... + + def patchify(self, latent_state: LatentState) -> LatentState: + """ + Patchify the latent state. + """ + if latent_state.latent.shape != self.target_shape.to_torch_shape(): + raise ValueError( + f"Latent state has shape {latent_state.latent.shape}, expected shape is " + f"{self.target_shape.to_torch_shape()}" + ) + latent_state = latent_state.clone() + latent = self.patchifier.patchify(latent_state.latent) + clean_latent = self.patchifier.patchify(latent_state.clean_latent) + denoise_mask = self.patchifier.patchify(latent_state.denoise_mask) + return replace(latent_state, latent=latent, denoise_mask=denoise_mask, clean_latent=clean_latent) + + def unpatchify(self, latent_state: LatentState) -> LatentState: + """ + Unpatchify the latent state. + """ + latent_state = latent_state.clone() + latent = self.patchifier.unpatchify(latent_state.latent, output_shape=self.target_shape) + clean_latent = self.patchifier.unpatchify(latent_state.clean_latent, output_shape=self.target_shape) + denoise_mask = self.patchifier.unpatchify( + latent_state.denoise_mask, output_shape=self.target_shape.mask_shape() + ) + return replace(latent_state, latent=latent, denoise_mask=denoise_mask, clean_latent=clean_latent) + + def clear_conditioning(self, latent_state: LatentState) -> LatentState: + """ + Clear the conditioning from the latent state. This method removes extra tokens from the end of the latent. + Therefore, conditioning items should add extra tokens ONLY to the end of the latent. + """ + latent_state = latent_state.clone() + + num_tokens = self.patchifier.get_token_count(self.target_shape) + latent = latent_state.latent[:, :num_tokens] + clean_latent = latent_state.clean_latent[:, :num_tokens] + denoise_mask = torch.ones_like(latent_state.denoise_mask)[:, :num_tokens] + positions = latent_state.positions[:, :, :num_tokens] + + return LatentState(latent=latent, denoise_mask=denoise_mask, positions=positions, clean_latent=clean_latent) + + +@dataclass(frozen=True) +class VideoLatentTools(LatentTools): + """ + Tools for building video latent states. + """ + + patchifier: VideoLatentPatchifier + target_shape: VideoLatentShape + fps: float + scale_factors: SpatioTemporalScaleFactors = DEFAULT_SCALE_FACTORS + causal_fix: bool = True + + def create_initial_state( + self, + device: DeviceLikeType, + dtype: torch.dtype, + initial_latent: torch.Tensor | None = None, + ) -> LatentState: + if initial_latent is not None: + assert initial_latent.shape == self.target_shape.to_torch_shape(), ( + f"Latent shape {initial_latent.shape} does not match target shape {self.target_shape.to_torch_shape()}" + ) + else: + initial_latent = torch.zeros( + *self.target_shape.to_torch_shape(), + device=device, + dtype=dtype, + ) + + clean_latent = initial_latent.clone() + + denoise_mask = torch.ones( + *self.target_shape.mask_shape().to_torch_shape(), + device=device, + dtype=torch.float32, + ) + + latent_coords = self.patchifier.get_patch_grid_bounds( + output_shape=self.target_shape, + device=device, + ) + + positions = get_pixel_coords( + latent_coords=latent_coords, + scale_factors=self.scale_factors, + causal_fix=self.causal_fix, + ).float() + positions[:, 0, ...] = positions[:, 0, ...] / self.fps + + return self.patchify( + LatentState( + latent=initial_latent, + denoise_mask=denoise_mask, + positions=positions.to(dtype), + clean_latent=clean_latent, + ) + ) + + +@dataclass(frozen=True) +class AudioLatentTools(LatentTools): + """ + Tools for building audio latent states. + """ + + patchifier: AudioPatchifier + target_shape: AudioLatentShape + + def create_initial_state( + self, + device: DeviceLikeType, + dtype: torch.dtype, + initial_latent: torch.Tensor | None = None, + ) -> LatentState: + if initial_latent is not None: + assert initial_latent.shape == self.target_shape.to_torch_shape(), ( + f"Latent shape {initial_latent.shape} does not match target shape {self.target_shape.to_torch_shape()}" + ) + else: + initial_latent = torch.zeros( + *self.target_shape.to_torch_shape(), + device=device, + dtype=dtype, + ) + + clean_latent = initial_latent.clone() + + denoise_mask = torch.ones( + *self.target_shape.mask_shape().to_torch_shape(), + device=device, + dtype=torch.float32, + ) + + latent_coords = self.patchifier.get_patch_grid_bounds( + output_shape=self.target_shape, + device=device, + ) + + return self.patchify( + LatentState( + latent=initial_latent, denoise_mask=denoise_mask, positions=latent_coords, clean_latent=clean_latent + ) + ) diff --git a/src/musubi_tuner/ltx_2/types.py b/src/musubi_tuner/ltx_2/types.py new file mode 100644 index 0000000000000000000000000000000000000000..0f91289d0cfb311584d45a40e33b0821fb4ee4dd --- /dev/null +++ b/src/musubi_tuner/ltx_2/types.py @@ -0,0 +1,181 @@ +from dataclasses import dataclass +from typing import NamedTuple + +import torch + + +class VideoPixelShape(NamedTuple): + """ + Shape of the tensor representing the video pixel array. Assumes BGR channel format. + """ + + batch: int + frames: int + height: int + width: int + fps: float + + +class SpatioTemporalScaleFactors(NamedTuple): + """ + Describes the spatiotemporal downscaling between decoded video space and + the corresponding VAE latent grid. + """ + + time: int + width: int + height: int + + @classmethod + def default(cls) -> "SpatioTemporalScaleFactors": + return cls(time=8, width=32, height=32) + + +VIDEO_SCALE_FACTORS = SpatioTemporalScaleFactors.default() + + +class VideoLatentShape(NamedTuple): + """ + Shape of the tensor representing video in VAE latent space. + The latent representation is a 5D tensor with dimensions ordered as + (batch, channels, frames, height, width). Spatial and temporal dimensions + are downscaled relative to pixel space according to the VAE's scale factors. + """ + + batch: int + channels: int + frames: int + height: int + width: int + + def to_torch_shape(self) -> torch.Size: + return torch.Size([self.batch, self.channels, self.frames, self.height, self.width]) + + @staticmethod + def from_torch_shape(shape: torch.Size) -> "VideoLatentShape": + return VideoLatentShape( + batch=shape[0], + channels=shape[1], + frames=shape[2], + height=shape[3], + width=shape[4], + ) + + def mask_shape(self) -> "VideoLatentShape": + return self._replace(channels=1) + + @staticmethod + def from_pixel_shape( + shape: VideoPixelShape, + latent_channels: int = 128, + scale_factors: SpatioTemporalScaleFactors = VIDEO_SCALE_FACTORS, + ) -> "VideoLatentShape": + frames = (shape.frames - 1) // scale_factors[0] + 1 + height = shape.height // scale_factors[1] + width = shape.width // scale_factors[2] + + return VideoLatentShape( + batch=shape.batch, + channels=latent_channels, + frames=frames, + height=height, + width=width, + ) + + def upscale(self, scale_factors: SpatioTemporalScaleFactors = VIDEO_SCALE_FACTORS) -> "VideoLatentShape": + return self._replace( + channels=3, + frames=(self.frames - 1) * scale_factors.time + 1, + height=self.height * scale_factors.height, + width=self.width * scale_factors.width, + ) + + +class AudioLatentShape(NamedTuple): + """ + Shape of audio in VAE latent space: (batch, channels, frames, mel_bins). + mel_bins is the number of frequency bins from the mel-spectrogram encoding. + """ + + batch: int + channels: int + frames: int + mel_bins: int + + def to_torch_shape(self) -> torch.Size: + return torch.Size([self.batch, self.channels, self.frames, self.mel_bins]) + + def mask_shape(self) -> "AudioLatentShape": + return self._replace(channels=1, mel_bins=1) + + @staticmethod + def from_torch_shape(shape: torch.Size) -> "AudioLatentShape": + return AudioLatentShape( + batch=shape[0], + channels=shape[1], + frames=shape[2], + mel_bins=shape[3], + ) + + @staticmethod + def from_duration( + batch: int, + duration: float, + channels: int = 8, + mel_bins: int = 16, + sample_rate: int = 16000, + hop_length: int = 160, + audio_latent_downsample_factor: int = 4, + ) -> "AudioLatentShape": + latents_per_second = float(sample_rate) / float(hop_length) / float(audio_latent_downsample_factor) + + return AudioLatentShape( + batch=batch, + channels=channels, + frames=round(duration * latents_per_second), + mel_bins=mel_bins, + ) + + @staticmethod + def from_video_pixel_shape( + shape: VideoPixelShape, + channels: int = 8, + mel_bins: int = 16, + sample_rate: int = 16000, + hop_length: int = 160, + audio_latent_downsample_factor: int = 4, + ) -> "AudioLatentShape": + return AudioLatentShape.from_duration( + batch=shape.batch, + duration=float(shape.frames) / float(shape.fps), + channels=channels, + mel_bins=mel_bins, + sample_rate=sample_rate, + hop_length=hop_length, + audio_latent_downsample_factor=audio_latent_downsample_factor, + ) + + +@dataclass(frozen=True) +class LatentState: + """ + State of latents during the diffusion denoising process. + Attributes: + latent: The current noisy latent tensor being denoised. + denoise_mask: Mask encoding the denoising strength for each token (1 = full denoising, 0 = no denoising). + positions: Positional indices for each latent element, used for positional embeddings. + clean_latent: Initial state of the latent before denoising, may include conditioning latents. + """ + + latent: torch.Tensor + denoise_mask: torch.Tensor + positions: torch.Tensor + clean_latent: torch.Tensor + + def clone(self) -> "LatentState": + return LatentState( + latent=self.latent.clone(), + denoise_mask=self.denoise_mask.clone(), + positions=self.positions.clone(), + clean_latent=self.clean_latent.clone(), + ) diff --git a/src/musubi_tuner/ltx_2/utils.py b/src/musubi_tuner/ltx_2/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..61ad2d9b34b943c5374bf7bb8c38a507986de32f --- /dev/null +++ b/src/musubi_tuner/ltx_2/utils.py @@ -0,0 +1,141 @@ +from dataclasses import fields, is_dataclass, replace as dataclass_replace +from typing import Any, Callable + +import torch + + + +def to_device(x: Any, device: torch.device) -> Any: + """Recursively moves torch.Tensor objects (and containers thereof) to device. + + Supports: Tensor, list, tuple, dict, and frozen dataclass objects. + """ + if isinstance(x, torch.Tensor): + return x.to(device) + if isinstance(x, list): + return [to_device(elem, device) for elem in x] + if isinstance(x, tuple): + return tuple(to_device(elem, device) for elem in x) + if isinstance(x, dict): + return {k: to_device(v, device) for k, v in x.items()} + if is_dataclass(x) and not isinstance(x, type): + field_updates = {f.name: to_device(getattr(x, f.name), device) for f in fields(x)} + return dataclass_replace(x, **field_updates) + return x + + +def to_cpu(x: Any) -> Any: + """Recursively moves torch.Tensor objects (and containers thereof) to CPU.""" + if isinstance(x, torch.Tensor): + return x.cpu() + if isinstance(x, list): + return [to_cpu(elem) for elem in x] + if isinstance(x, tuple): + return tuple(to_cpu(elem) for elem in x) + if isinstance(x, dict): + return {k: to_cpu(v) for k, v in x.items()} + if is_dataclass(x) and not isinstance(x, type): + field_updates = {f.name: to_cpu(getattr(x, f.name)) for f in fields(x)} + return dataclass_replace(x, **field_updates) + return x + + +def create_cpu_offloading_wrapper(func: Callable, device: torch.device) -> Callable: + """ + Create a wrapper function that offloads inputs to CPU before calling the original function + and moves outputs back to the specified device. + """ + + def wrapper(orig_func: Callable) -> Callable: + def custom_forward(*inputs): + nonlocal device, orig_func + cuda_inputs = to_device(inputs, device) + outputs = orig_func(*cuda_inputs) + return to_cpu(outputs) + + return custom_forward + + return wrapper(func) + + +def rms_norm(x: torch.Tensor, weight: torch.Tensor | None = None, eps: float = 1e-6) -> torch.Tensor: + """Root-mean-square (RMS) normalize `x` over its last dimension. + Thin wrapper around `torch.nn.functional.rms_norm` that infers the normalized + shape and forwards `weight` and `eps`. + + NOTE: Modified to run in Float32 to prevent overflows/NaNs in mixed precision training. + """ + input_dtype = x.dtype + # Force Float32 for stability + # This prevents 'inf' gradients caused by overflow in squared sum calculation + x = x.to(torch.float32) + if weight is not None: + weight = weight.to(torch.float32) + + res = torch.nn.functional.rms_norm(x, (x.shape[-1],), weight=weight, eps=eps) + + return res.to(input_dtype) + + + + +class RMSNorm(torch.nn.Module): + """ + Robust RMSNorm module that uses the stabilized functional wrapper. + Replaces torch.nn.RMSNorm to ensure mixed-precision compatibility (F8/F32/BF16). + """ + def __init__(self, dim: int, eps: float = 1e-6, elementwise_affine: bool = True): + super().__init__() + self.normalized_shape = (dim,) + self.eps = eps + self.elementwise_affine = elementwise_affine + if self.elementwise_affine: + self.weight = torch.nn.Parameter(torch.ones(dim)) + else: + self.register_parameter("weight", None) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return rms_norm(x, self.weight, self.eps) + + def extra_repr(self) -> str: + return f"{self.normalized_shape}, eps={self.eps}, elementwise_affine={self.elementwise_affine}" + + +def check_config_value(config: dict, key: str, expected: Any) -> None: # noqa: ANN401 + actual = config.get(key) + if actual != expected: + raise ValueError(f"Config value {key} is {actual}, expected {expected}") + + +def to_velocity( + sample: torch.Tensor, + sigma: float | torch.Tensor, + denoised_sample: torch.Tensor, + calc_dtype: torch.dtype = torch.float32, +) -> torch.Tensor: + """ + Convert the sample and its denoised version to velocity. + Returns: + Velocity + """ + if isinstance(sigma, torch.Tensor): + sigma = sigma.to(calc_dtype).item() + if sigma == 0: + raise ValueError("Sigma can't be 0.0") + return ((sample.to(calc_dtype) - denoised_sample.to(calc_dtype)) / sigma).to(sample.dtype) + + +def to_denoised( + sample: torch.Tensor, + velocity: torch.Tensor, + sigma: float | torch.Tensor, + calc_dtype: torch.dtype = torch.float32, +) -> torch.Tensor: + """ + Convert the sample and its denoising velocity to denoised sample. + Returns: + Denoised sample + """ + if isinstance(sigma, torch.Tensor): + sigma = sigma.to(calc_dtype) + return (sample.to(calc_dtype) - velocity.to(calc_dtype) * sigma).to(sample.dtype) diff --git a/src/musubi_tuner/modules/__init__.py b/src/musubi_tuner/modules/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/musubi_tuner/modules/adafactor_fused.py b/src/musubi_tuner/modules/adafactor_fused.py new file mode 100644 index 0000000000000000000000000000000000000000..79ea1c2f7fca5df9c3c6993952db84c847cd02fb --- /dev/null +++ b/src/musubi_tuner/modules/adafactor_fused.py @@ -0,0 +1,141 @@ +# copy from sd-scripts + +import math +import torch +from transformers import Adafactor + +# stochastic rounding for bfloat16 +# The implementation was provided by 2kpr. Thank you very much! + + +def copy_stochastic_(target: torch.Tensor, source: torch.Tensor): + """ + copies source into target using stochastic rounding + + Args: + target: the target tensor with dtype=bfloat16 + source: the target tensor with dtype=float32 + """ + # create a random 16 bit integer + result = torch.randint_like(source, dtype=torch.int32, low=0, high=(1 << 16)) + + # add the random number to the lower 16 bit of the mantissa + result.add_(source.view(dtype=torch.int32)) + + # mask off the lower 16 bit of the mantissa + result.bitwise_and_(-65536) # -65536 = FFFF0000 as a signed int32 + + # copy the higher 16 bit into the target tensor + target.copy_(result.view(dtype=torch.float32)) + + del result + + +@torch.no_grad() +def adafactor_step_param(self, p, group): + if p.grad is None: + return + grad = p.grad + if grad.dtype in {torch.float16, torch.bfloat16}: + grad = grad.float() + if grad.is_sparse: + raise RuntimeError("Adafactor does not support sparse gradients.") + + state = self.state[p] + grad_shape = grad.shape + + factored, use_first_moment = Adafactor._get_options(group, grad_shape) + # State Initialization + if len(state) == 0: + state["step"] = 0 + + if use_first_moment: + # Exponential moving average of gradient values + state["exp_avg"] = torch.zeros_like(grad) + if factored: + state["exp_avg_sq_row"] = torch.zeros(grad_shape[:-1]).to(grad) + state["exp_avg_sq_col"] = torch.zeros(grad_shape[:-2] + grad_shape[-1:]).to(grad) + else: + state["exp_avg_sq"] = torch.zeros_like(grad) + + state["RMS"] = 0 + else: + if use_first_moment: + state["exp_avg"] = state["exp_avg"].to(grad) + if factored: + state["exp_avg_sq_row"] = state["exp_avg_sq_row"].to(grad) + state["exp_avg_sq_col"] = state["exp_avg_sq_col"].to(grad) + else: + state["exp_avg_sq"] = state["exp_avg_sq"].to(grad) + + p_data_fp32 = p + if p.dtype in {torch.float16, torch.bfloat16}: + p_data_fp32 = p_data_fp32.float() + + state["step"] += 1 + state["RMS"] = Adafactor._rms(p_data_fp32) + lr = Adafactor._get_lr(group, state) + + beta2t = 1.0 - math.pow(state["step"], group["decay_rate"]) + update = (grad**2) + group["eps"][0] + if factored: + exp_avg_sq_row = state["exp_avg_sq_row"] + exp_avg_sq_col = state["exp_avg_sq_col"] + + exp_avg_sq_row.mul_(beta2t).add_(update.mean(dim=-1), alpha=(1.0 - beta2t)) + exp_avg_sq_col.mul_(beta2t).add_(update.mean(dim=-2), alpha=(1.0 - beta2t)) + + # Approximation of exponential moving average of square of gradient + update = Adafactor._approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col) + update.mul_(grad) + else: + exp_avg_sq = state["exp_avg_sq"] + + exp_avg_sq.mul_(beta2t).add_(update, alpha=(1.0 - beta2t)) + update = exp_avg_sq.rsqrt().mul_(grad) + + update.div_((Adafactor._rms(update) / group["clip_threshold"]).clamp_(min=1.0)) + update.mul_(lr) + + if use_first_moment: + exp_avg = state["exp_avg"] + exp_avg.mul_(group["beta1"]).add_(update, alpha=(1 - group["beta1"])) + update = exp_avg + + if group["weight_decay"] != 0: + p_data_fp32.add_(p_data_fp32, alpha=(-group["weight_decay"] * lr)) + + p_data_fp32.add_(-update) + + # if p.dtype in {torch.float16, torch.bfloat16}: + # p.copy_(p_data_fp32) + + if p.dtype == torch.bfloat16: + copy_stochastic_(p, p_data_fp32) + elif p.dtype == torch.float16: + p.copy_(p_data_fp32) + + +@torch.no_grad() +def adafactor_step(self, closure=None): + """ + Performs a single optimization step + + Arguments: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + for p in group["params"]: + adafactor_step_param(self, p, group) + + return loss + + +def patch_adafactor_fused(optimizer: Adafactor): + optimizer.step_param = adafactor_step_param.__get__(optimizer) + optimizer.step = adafactor_step.__get__(optimizer) diff --git a/src/musubi_tuner/modules/attention.py b/src/musubi_tuner/modules/attention.py new file mode 100644 index 0000000000000000000000000000000000000000..8d11f05f21e28b216678bf2197dbd6cab19e815c --- /dev/null +++ b/src/musubi_tuner/modules/attention.py @@ -0,0 +1,267 @@ +# Unified attention function supporting various implementations + +from dataclasses import dataclass +import torch +from typing import Optional, Union + +try: + import flash_attn + from flash_attn.flash_attn_interface import _flash_attn_forward + from flash_attn.flash_attn_interface import flash_attn_varlen_func + from flash_attn.flash_attn_interface import flash_attn_func +except ImportError: + flash_attn = None + flash_attn_varlen_func = None + _flash_attn_forward = None + flash_attn_func = None + +try: + from sageattention import sageattn_varlen, sageattn +except ImportError: + sageattn_varlen = None + sageattn = None + +try: + import xformers.ops as xops +except ImportError: + xops = None + + +@dataclass +class AttentionParams: + attn_mode: Optional[str] = None + split_attn: bool = False + img_len: Optional[int] = None + attention_mask: Optional[torch.Tensor] = None + seqlens: Optional[torch.Tensor] = None + cu_seqlens: Optional[torch.Tensor] = None + max_seqlen: Optional[int] = None + + @staticmethod + def create_attention_params(attn_mode: Optional[str], split_attn: bool) -> "AttentionParams": + return AttentionParams(attn_mode, split_attn) + + @staticmethod + def create_attention_params_from_mask( + attn_mode: Optional[str], split_attn: bool, img_len: Optional[int], attention_mask: Optional[torch.Tensor] + ) -> "AttentionParams": + if attention_mask is None: + # No attention mask provided: assume all tokens are valid + return AttentionParams(attn_mode, split_attn, None, None, None, None, None) + else: + # Note: attention_mask is only for text tokens, not including image tokens + seqlens = attention_mask.sum(dim=1).to(torch.int32) + img_len # [B] + max_seqlen = attention_mask.shape[1] + img_len + + if split_attn: + # cu_seqlens is not needed for split attention + return AttentionParams(attn_mode, split_attn, img_len, attention_mask, seqlens, None, max_seqlen) + + # Convert attention mask to cumulative sequence lengths for flash attention + batch_size = attention_mask.shape[0] + cu_seqlens = torch.zeros([2 * batch_size + 1], dtype=torch.int32, device=attention_mask.device) + for i in range(batch_size): + cu_seqlens[2 * i + 1] = i * max_seqlen + seqlens[i] # end of valid tokens for query + cu_seqlens[2 * i + 2] = (i + 1) * max_seqlen # end of all tokens for query + + # Expand attention mask to include image tokens + attention_mask = torch.nn.functional.pad(attention_mask, (img_len, 0), value=1) # [B, img_len + L] + + # attention bias for xformers + if attn_mode == "xformers": + seqlens_list = seqlens.cpu().tolist() + attention_mask = xops.fmha.attn_bias.BlockDiagonalMask.from_seqlens( + seqlens_list, seqlens_list, device=attention_mask.device + ) + elif attn_mode == "torch": + attention_mask = attention_mask[:, None, None, :].to(torch.bool) # [B, 1, 1, img_len + L] + + return AttentionParams(attn_mode, split_attn, img_len, attention_mask, seqlens, cu_seqlens, max_seqlen) + + +def attention( + qkv_or_q: Union[torch.Tensor, list], + k: Optional[torch.Tensor] = None, + v: Optional[torch.Tensor] = None, + attn_params: Optional[AttentionParams] = None, + drop_rate: float = 0.0, +) -> torch.Tensor: + """ + Compute scaled dot-product attention with variable sequence lengths. + + Handles batches with different sequence lengths by splitting and + processing each sequence individually. + + Args: + qkv_or_q: Query tensor [B, L, H, D]. or list of such tensors. + k: Key tensor [B, L, H, D]. + v: Value tensor [B, L, H, D]. + attn_param: Attention parameters including mask and sequence lengths. + drop_rate: Attention dropout rate. + + Returns: + Attention output tensor [B, L, H*D]. + """ + if isinstance(qkv_or_q, list): + q, k, v = qkv_or_q + q: torch.Tensor = q + qkv_or_q.clear() + del qkv_or_q + else: + q: torch.Tensor = qkv_or_q + del qkv_or_q + assert k is not None and v is not None, "k and v must be provided if qkv_or_q is a tensor" + if attn_params is None: + attn_params = AttentionParams.create_attention_params("torch", False) + + # If split attn is False, attention mask is provided and all sequence lengths are same, we can trim the sequence + seqlen_trimmed = False + # Trim if all seqlens are the same, for attention modes other than flash or sageattn (which can handle masks efficiently) + if ( + not attn_params.split_attn + and attn_params.attention_mask is not None + and attn_params.seqlens is not None + and (attn_params.attn_mode != "flash" and attn_params.attn_mode != "sageattn") + ): + if torch.all(attn_params.seqlens == attn_params.seqlens[0]): + seqlen = attn_params.seqlens[0].item() + q = q[:, :seqlen] + k = k[:, :seqlen] + v = v[:, :seqlen] + max_seqlen = attn_params.max_seqlen + attn_params = AttentionParams.create_attention_params(attn_params.attn_mode, False) # do not in-place modify + attn_params.max_seqlen = max_seqlen # keep max_seqlen for padding + seqlen_trimmed = True + + # Determine tensor layout based on attention implementation + if attn_params.attn_mode == "torch" or ( + attn_params.attn_mode == "sageattn" and (attn_params.split_attn or attn_params.cu_seqlens is None) + ): + transpose_fn = lambda x: x.transpose(1, 2) # [B, H, L, D] for SDPA and sageattn with fixed length + # pad on sequence length dimension + pad_fn = lambda x, pad_to: torch.nn.functional.pad(x, (0, 0, 0, pad_to - x.shape[-2]), value=0) + else: + transpose_fn = lambda x: x # [B, L, H, D] for other implementations + # pad on sequence length dimension + pad_fn = lambda x, pad_to: torch.nn.functional.pad(x, (0, 0, 0, 0, 0, pad_to - x.shape[-3]), value=0) + + # Process each batch element with its valid sequence lengths + if attn_params.split_attn: + if attn_params.seqlens is None: + # If no seqlens provided, assume all tokens are valid + attn_params = AttentionParams.create_attention_params(attn_params.attn_mode, True) # do not in-place modify + attn_params.seqlens = torch.tensor([q.shape[1]] * q.shape[0], device=q.device) + attn_params.max_seqlen = q.shape[1] + q = [transpose_fn(q[i : i + 1, : attn_params.seqlens[i]]) for i in range(len(q))] + k = [transpose_fn(k[i : i + 1, : attn_params.seqlens[i]]) for i in range(len(k))] + v = [transpose_fn(v[i : i + 1, : attn_params.seqlens[i]]) for i in range(len(v))] + else: + q = transpose_fn(q) + k = transpose_fn(k) + v = transpose_fn(v) + + if attn_params.attn_mode == "torch": + if attn_params.split_attn: + x = [] + for i in range(len(q)): + x_i = torch.nn.functional.scaled_dot_product_attention(q[i], k[i], v[i], dropout_p=drop_rate) + q[i] = None + k[i] = None + v[i] = None + x.append(pad_fn(x_i, attn_params.max_seqlen)) # B, H, L, D + x = torch.cat(x, dim=0) + q, k, v = None, None, None + + else: + x = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=attn_params.attention_mask, dropout_p=drop_rate) + q, k, v = None, None, None + + elif attn_params.attn_mode == "xformers": + if attn_params.split_attn: + x = [] + for i in range(len(q)): + x_i = xops.memory_efficient_attention(q[i], k[i], v[i], p=drop_rate) + q[i] = None + k[i] = None + v[i] = None + x.append(pad_fn(x_i, attn_params.max_seqlen)) # B, L, H, D + x = torch.cat(x, dim=0) + q, k, v = None, None, None + + else: + x = xops.memory_efficient_attention(q, k, v, attn_bias=attn_params.attention_mask, p=drop_rate) + q, k, v = None, None, None + + elif attn_params.attn_mode == "sageattn": + if attn_params.split_attn: + x = [] + for i in range(len(q)): + # HND seems to cause an error + x_i = sageattn(q[i], k[i], v[i]) # B, H, L, D. No dropout support + q[i] = None + k[i] = None + v[i] = None + x.append(pad_fn(x_i, attn_params.max_seqlen)) # B, H, L, D + x = torch.cat(x, dim=0) + q, k, v = None, None, None + elif attn_params.cu_seqlens is None: # all tokens are valid + x = sageattn(q, k, v) # B, L, H, D. No dropout support + q, k, v = None, None, None + else: + # Reshape to [(bxs), a, d] + batch_size, seqlen = q.shape[0], q.shape[1] + q = q.view(q.shape[0] * q.shape[1], *q.shape[2:]) # [B*L, H, D] + k = k.view(k.shape[0] * k.shape[1], *k.shape[2:]) # [B*L, H, D] + v = v.view(v.shape[0] * v.shape[1], *v.shape[2:]) # [B*L, H, D] + + # Assume cu_seqlens_q == cu_seqlens_kv and max_seqlen_q == max_seqlen_kv. No dropout support + x = sageattn_varlen( + q, k, v, attn_params.cu_seqlens, attn_params.cu_seqlens, attn_params.max_seqlen, attn_params.max_seqlen + ) + q, k, v = None, None, None + + # Reshape x with shape [(bxs), a, d] to [b, s, a, d] + x = x.view(batch_size, seqlen, x.shape[-2], x.shape[-1]) # B, L, H, D + + elif attn_params.attn_mode == "flash": + if attn_params.split_attn: + x = [] + for i in range(len(q)): + # HND seems to cause an error + x_i = flash_attn_func(q[i], k[i], v[i], drop_rate) # B, L, H, D + q[i] = None + k[i] = None + v[i] = None + x.append(pad_fn(x_i, attn_params.max_seqlen)) # B, L, H, D + x = torch.cat(x, dim=0) + q, k, v = None, None, None + elif attn_params.cu_seqlens is None: # all tokens are valid + x = flash_attn_func(q, k, v, drop_rate) # B, L, H, D + q, k, v = None, None, None + else: + # Reshape to [(bxs), a, d] + batch_size, seqlen = q.shape[0], q.shape[1] + q = q.view(q.shape[0] * q.shape[1], *q.shape[2:]) # [B*L, H, D] + k = k.view(k.shape[0] * k.shape[1], *k.shape[2:]) # [B*L, H, D] + v = v.view(v.shape[0] * v.shape[1], *v.shape[2:]) # [B*L, H, D] + + # Assume cu_seqlens_q == cu_seqlens_kv and max_seqlen_q == max_seqlen_kv + x = flash_attn_varlen_func( + q, k, v, attn_params.cu_seqlens, attn_params.cu_seqlens, attn_params.max_seqlen, attn_params.max_seqlen, drop_rate + ) + q, k, v = None, None, None + + # Reshape x with shape [(bxs), a, d] to [b, s, a, d] + x = x.view(batch_size, seqlen, x.shape[-2], x.shape[-1]) # B, L, H, D + + else: + # Currently only PyTorch SDPA and xformers are implemented + raise ValueError(f"Unsupported attention mode: {attn_params.attn_mode}") + + x = transpose_fn(x) # [B, L, H, D] + x = x.reshape(x.shape[0], x.shape[1], -1) # [B, L, H*D] + + if seqlen_trimmed: + x = torch.nn.functional.pad(x, (0, 0, 0, attn_params.max_seqlen - x.shape[1]), value=0) # pad back to max_seqlen + + return x diff --git a/src/musubi_tuner/modules/awq_calibration.py b/src/musubi_tuner/modules/awq_calibration.py new file mode 100644 index 0000000000000000000000000000000000000000..dcee9d2d3c73f984522c44ef86b5abf128651a3c --- /dev/null +++ b/src/musubi_tuner/modules/awq_calibration.py @@ -0,0 +1,314 @@ +"""AWQ-style activation-aware scaling for NF4 quantization. + +Computes per-channel importance scores from activation statistics and weight +magnitudes, then scales weight columns so that high-importance channels get +more effective quantization precision. + +Reference: Lin et al., "AWQ: Activation-aware Weight Quantization" (2023). +""" + +import os +import logging +from typing import Callable, Dict, List, Optional + +import torch +import torch.nn as nn + +logger = logging.getLogger(__name__) + + +@torch.no_grad() +def collect_activation_stats( + model: nn.Module, + calibration_fn: Callable, + num_batches: int = 8, + target_layer_keys: Optional[List[str]] = None, + exclude_layer_keys: Optional[List[str]] = None, +) -> Dict[str, torch.Tensor]: + """Collect per-channel activation L2 norms from forward passes. + + Args: + model: The model (with full-precision weights loaded). + calibration_fn: Callable that runs one forward pass (no return value needed). + num_batches: Number of forward passes to collect statistics. + target_layer_keys: Only collect stats for layers whose name contains one of these. + exclude_layer_keys: Skip layers whose name contains one of these. + + Returns: + Dict mapping module name -> per-channel activation norm tensor [in_features]. + """ + + def _is_target(name: str) -> bool: + is_target = target_layer_keys is None or any(p in name for p in target_layer_keys) + is_excluded = exclude_layer_keys is not None and any(p in name for p in exclude_layer_keys) + return is_target and not is_excluded + + act_sums: Dict[str, torch.Tensor] = {} + act_counts: Dict[str, int] = {} + hooks = [] + + for name, module in model.named_modules(): + if not isinstance(module, nn.Linear): + continue + if not _is_target(name): + continue + + def make_hook(mod_name): + def hook_fn(module, input, output): + x = input[0] # [batch, seq, in_features] + if x.ndim == 2: + x = x.unsqueeze(0) + # Mean absolute activation per channel across batch and sequence dims + channel_norm = x.float().abs().mean(dim=tuple(range(x.ndim - 1))) # [in_features] + if mod_name not in act_sums: + act_sums[mod_name] = channel_norm.cpu() + else: + act_sums[mod_name] += channel_norm.cpu() + act_counts[mod_name] = act_counts.get(mod_name, 0) + 1 + return hook_fn + + h = module.register_forward_hook(make_hook(name)) + hooks.append(h) + + # Run calibration forward passes + for i in range(num_batches): + try: + calibration_fn() + except Exception as e: + logger.warning("AWQ calibration batch %d failed: %s", i, e) + break + + # Remove hooks + for h in hooks: + h.remove() + + # Average the accumulated norms + act_stats: Dict[str, torch.Tensor] = {} + for name, total in act_sums.items(): + count = act_counts[name] + act_stats[name] = total / count + + logger.info("AWQ: collected activation stats for %d layers over %d batches", + len(act_stats), num_batches) + return act_stats + + +@torch.no_grad() +def compute_awq_scales( + state_dict: dict, + act_stats: Dict[str, torch.Tensor], + alpha: float = 0.25, + target_layer_keys: Optional[List[str]] = None, + exclude_layer_keys: Optional[List[str]] = None, +) -> Dict[str, torch.Tensor]: + """Compute per-channel AWQ scales from activation stats and weight magnitudes. + + Args: + state_dict: Full-precision state dict (keys ending in ".weight"). + act_stats: Per-channel activation norms from collect_activation_stats. + alpha: Scaling strength (0 = no effect, 1 = full activation-aware). Default 0.25. + target_layer_keys: Only compute scales for matching keys. + exclude_layer_keys: Skip matching keys. + + Returns: + Dict mapping weight key (e.g. "layer.weight") -> scale tensor [in_features]. + """ + + def _is_target(key: str) -> bool: + is_target = target_layer_keys is None or any(p in key for p in target_layer_keys) + is_excluded = exclude_layer_keys is not None and any(p in key for p in exclude_layer_keys) + return is_target and not is_excluded + + # Build mapping from weight key to module name + # Weight keys look like "transformer_blocks.0.attn.to_q.weight" + # Module names look like "transformer_blocks.0.attn.to_q" + scales: Dict[str, torch.Tensor] = {} + matched = 0 + + for key in list(state_dict.keys()): + if not key.endswith(".weight"): + continue + if not _is_target(key): + continue + w = state_dict[key] + if w.ndim != 2: + continue + + module_name = key[:-len(".weight")] # strip ".weight" + + if module_name not in act_stats: + continue + + act_norm = act_stats[module_name].float() # [in_features] + w_norm = w.float().abs().amax(dim=0) # max over output dim -> [in_features] + + # Importance = activation magnitude * weight magnitude + importance = act_norm.to(w_norm.device) * w_norm + mean_imp = importance.mean().clamp(min=1e-8) + + # Scale: channels with above-average importance get scaled up (> 1) + scale = (importance / mean_imp).pow(alpha).clamp(min=1e-5) + + scales[key] = scale + matched += 1 + + logger.info("AWQ: computed scales for %d / %d activation-profiled layers", matched, len(act_stats)) + return scales + + +@torch.no_grad() +def apply_awq_scales_to_state_dict( + state_dict: dict, + awq_scales: Dict[str, torch.Tensor], +) -> None: + """Scale weight columns by AWQ scales before quantization (in-place). + + After quantization, the forward pass must divide by these same scales to + preserve the original weight semantics. + + Args: + state_dict: State dict to modify in-place. + awq_scales: Per-weight-key scale tensors from compute_awq_scales. + """ + for key, scale in awq_scales.items(): + if key in state_dict: + w = state_dict[key].float() + # Scale columns: W[:, i] *= s[i] + state_dict[key] = (w * scale.to(w.device).unsqueeze(0)).to(state_dict[key].dtype) + + +def save_awq_scales(scales: Dict[str, torch.Tensor], path: str) -> None: + """Save AWQ scales to a safetensors file.""" + from safetensors.torch import save_file + save_file(scales, path) + logger.info("AWQ: saved scales (%d layers) to %s", len(scales), path) + + +def load_awq_scales(path: str) -> Dict[str, torch.Tensor]: + """Load AWQ scales from a safetensors file.""" + from safetensors.torch import load_file + scales = load_file(path) + logger.info("AWQ: loaded scales (%d layers) from %s", len(scales), path) + return scales + + +def get_awq_cache_path(model_path: str) -> str: + """Get the default AWQ scales cache path for a model file.""" + if isinstance(model_path, list): + model_path = model_path[0] + base, _ = os.path.splitext(model_path) + return base + ".awq_scales.safetensors" + + +@torch.no_grad() +def run_synthetic_calibration( + model: nn.Module, + state_dict: dict, + num_batches: int = 8, + alpha: float = 0.25, + target_layer_keys: Optional[List[str]] = None, + exclude_layer_keys: Optional[List[str]] = None, + device: torch.device = torch.device("cpu"), +) -> Dict[str, torch.Tensor]: + """Run AWQ calibration using synthetic random inputs (no dataloader needed). + + For diffusion transformers, random Gaussian inputs are representative because + the model processes Gaussian noise at various timesteps during training. + + This function: + 1. Temporarily loads full-precision weights into the model + 2. Runs synthetic forward passes to collect activation statistics + 3. Computes per-channel AWQ scales + 4. Restores the model to meta tensors (to free memory) + + Args: + model: The transformer model (on meta device or CPU). + state_dict: Full-precision state dict. + num_batches: Number of synthetic batches for calibration. + alpha: AWQ scaling strength. + target_layer_keys: Only process matching layers. + exclude_layer_keys: Skip matching layers. + device: Device to run calibration on. + + Returns: + Dict mapping weight key -> scale tensor [in_features]. + """ + # Load full-precision weights temporarily + logger.info("AWQ: loading full-precision weights for calibration...") + model.load_state_dict(state_dict, strict=False, assign=True) + model = model.to(device) + model.eval() + + # Determine input shape from the model's first Linear layer + # LTX-2 transformer expects patchified latent input + # We just need activations flowing through Linear layers — synthetic random is fine + first_linear = None + for module in model.modules(): + if isinstance(module, nn.Linear): + first_linear = module + break + + if first_linear is None: + logger.warning("AWQ: no Linear layers found in model, skipping calibration") + return {} + + # Find all input dims we need for the calibration + # We'll hook into the layers and just feed a plausible random input through the model + def calibration_fn(): + # Generate synthetic input: random normal as if it were a noisy latent + # Shape doesn't matter much since we only care about per-channel statistics + # at the Linear layer level, and hooks capture the actual input + try: + # Try a simple forward with synthetic hidden states + # The model's forward signature varies, so we construct a minimal input + # that exercises the transformer blocks + batch_size = 1 + # Use a small sequence length to keep memory low + seq_len = 64 + # Infer hidden dim from the model + hidden_dim = None + for name, p in model.named_parameters(): + if "transformer_blocks" in name and name.endswith(".weight") and p.ndim == 2: + # For attention layers, in_features = hidden_dim typically + hidden_dim = p.shape[1] + break + if hidden_dim is None: + hidden_dim = 3072 # fallback + + x = torch.randn(batch_size, seq_len, hidden_dim, device=device, dtype=torch.bfloat16) + # Just run through transformer_blocks directly if possible + if hasattr(model, "transformer_blocks"): + for block in model.transformer_blocks: + # Pass through with minimal args — this will likely fail but hooks still fire + # on whatever Linears get called before the error + try: + x = block(x) + except Exception: + pass + else: + # Try full forward — will fail but hooks still capture some stats + model(x) + except Exception: + pass + + act_stats = collect_activation_stats( + model, + calibration_fn=calibration_fn, + num_batches=num_batches, + target_layer_keys=target_layer_keys, + exclude_layer_keys=exclude_layer_keys, + ) + + # Compute scales from activation stats + weight magnitudes + scales = compute_awq_scales( + state_dict, + act_stats, + alpha=alpha, + target_layer_keys=target_layer_keys, + exclude_layer_keys=exclude_layer_keys, + ) + + # Free the model weights (move back to CPU to release GPU memory) + model = model.to("cpu") + + return scales diff --git a/src/musubi_tuner/modules/custom_offloading_utils.py b/src/musubi_tuner/modules/custom_offloading_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..357f3bd2d2a959b1a97dda31bed6a9275d176722 --- /dev/null +++ b/src/musubi_tuner/modules/custom_offloading_utils.py @@ -0,0 +1,479 @@ +from collections import defaultdict +from concurrent.futures import ThreadPoolExecutor +from contextlib import contextmanager +import gc +import time +from typing import Optional +import torch +import torch.nn as nn + + +# Keep these functions here for portability, and private to avoid confusion with the ones in device_utils.py +def _clean_memory_on_device(device: torch.device): + r""" + Clean memory on the specified device, will be called from training scripts. + """ + gc.collect() + + # device may "cuda" or "cuda:0", so we need to check the type of device + if device.type == "cuda": + torch.cuda.empty_cache() + if device.type == "xpu": + torch.xpu.empty_cache() + if device.type == "mps": + torch.mps.empty_cache() + + +def _synchronize_device(device: torch.device): + if device.type == "cuda": + torch.cuda.synchronize() + elif device.type == "xpu": + torch.xpu.synchronize() + elif device.type == "mps": + torch.mps.synchronize() + + +def swap_weight_devices_no_cuda(device: torch.device, layer_to_cpu: nn.Module, layer_to_cuda: nn.Module): + """ + not tested + """ + assert layer_to_cpu.__class__ == layer_to_cuda.__class__ + + weight_swap_jobs = [] + for module_to_cpu, module_to_cuda in zip(layer_to_cpu.modules(), layer_to_cuda.modules()): + if hasattr(module_to_cpu, "weight") and module_to_cpu.weight is not None: + weight_swap_jobs.append((module_to_cpu, module_to_cuda, module_to_cpu.weight.data, module_to_cuda.weight.data)) + + # device to cpu + for module_to_cpu, module_to_cuda, cuda_data_view, cpu_data_view in weight_swap_jobs: + module_to_cpu.weight.data = cuda_data_view.data.to("cpu", non_blocking=True) + + _synchronize_device(device) + + # cpu to device + for module_to_cpu, module_to_cuda, cuda_data_view, cpu_data_view in weight_swap_jobs: + cuda_data_view.copy_(module_to_cuda.weight.data, non_blocking=True) + module_to_cuda.weight.data = cuda_data_view + + _synchronize_device(device) + + +def weighs_to_device(layer: nn.Module, device: torch.device): + for module in layer.modules(): + if hasattr(module, "weight") and module.weight is not None and module.__class__.__name__.endswith("Linear"): + module.weight.data = module.weight.data.to(device, non_blocking=device.type != "cpu") + + +class Offloader: + """ + common offloading class + """ + + def __init__( + self, + block_type: str, + num_blocks: int, + blocks_to_swap: int, + device: torch.device, + use_pinned_memory: bool = False, + debug: bool = False, + ): + self.block_type = block_type + self.num_blocks = num_blocks + self.blocks_to_swap = blocks_to_swap + self.device = device + self.use_pinned_memory = use_pinned_memory + + # check if debug is enabled from os environment variable + if not debug: + import os + + debug = os.getenv("MUSUBI_TUNER_OFFLOADER_DEBUG", "0") == "1" + + self.debug = debug + self.debug_block_count = 0 + + self.thread_pool = ThreadPoolExecutor(max_workers=1) + self.futures = {} + self.cuda_available = device.type == "cuda" + self.stream = torch.cuda.Stream(device=device) if self.cuda_available else None + + # Staging buffers for cuda offloading without large pinned memory. These are pinned memory buffers to speed up the transfer between CPU and GPU + # We create one staging buffer per transfer direction (A: GPU to CPU, B: CPU to GPU) + self.staging_buffer_a = None + self.staging_buffer_b = None + + # Pinned buffer for cuda offloading with pinned memory. We need only one pinned buffer per layer transfer + self.pinned_buffer = None + + def swap_weight_devices_cuda(self, device: torch.device, layer_to_cpu: nn.Module, layer_to_cuda: nn.Module): + assert layer_to_cpu.__class__ == layer_to_cuda.__class__ + + debug_print = False + if self.debug: + debug_print = self.debug_block_count % 10 == 0 + self.debug_block_count += 1 + + class Timer: + def __init__(self, enabled=False): + self.enabled = enabled + self.totals = defaultdict(float) + self.start_time = time.perf_counter() + + @contextmanager + def section(self, name): + if not self.enabled: + yield + return + t0 = time.perf_counter() + try: + yield + finally: + self.totals[name] += time.perf_counter() - t0 + + T = Timer(enabled=debug_print) + + weight_swap_jobs = [] + + # This is not working for all cases (e.g. SD3), so we need to find the corresponding modules. kept here for reference: + # for module_to_cpu, module_to_cuda in zip(layer_to_cpu.modules(), layer_to_cuda.modules()): + # print(module_to_cpu.__class__, module_to_cuda.__class__) + # if hasattr(module_to_cpu, "weight") and module_to_cpu.weight is not None: + # weight_swap_jobs.append((module_to_cpu, module_to_cuda, module_to_cpu.weight.data, module_to_cuda.weight.data)) + + with T.section("find modules"): + modules_to_cpu = {k: v for k, v in layer_to_cpu.named_modules()} + for module_to_cuda_name, module_to_cuda in layer_to_cuda.named_modules(): + if ( + hasattr(module_to_cuda, "weight") + and module_to_cuda.weight is not None + and module_to_cuda.__class__.__name__.endswith("Linear") + ): + module_to_cpu = modules_to_cpu.get(module_to_cuda_name, None) + if module_to_cpu is not None and module_to_cpu.weight.shape == module_to_cuda.weight.shape: + weight_swap_jobs.append( + (module_to_cpu, module_to_cuda, module_to_cpu.weight.data, module_to_cuda.weight.data) + ) + else: + if module_to_cuda.weight.data.device.type != device.type: + module_to_cuda.weight.data = module_to_cuda.weight.data.to(device) + + with T.section("synchronize before swap"): + torch.cuda.current_stream().synchronize() # this prevents the illegal loss value by ensuring offloading layer's calculation is done + + if not self.use_pinned_memory: + # Minimize using pinned memory for lower shared GPU RAM usage + stream = self.stream + with torch.cuda.stream(stream): + if self.staging_buffer_a is None: + # Create staging buffer as pinned memory (as shared GPU ram). We specify device for correct pinning on multi-GPU systems + self.staging_buffer_a = [ + torch.empty_like(cuda_data_view, device="cpu").pin_memory(device=device) + for _, _, cuda_data_view, _ in weight_swap_jobs + ] + self.staging_buffer_b = [ + torch.empty_like(cuda_data_view, device="cpu").pin_memory(device=device) + for _, _, cuda_data_view, _ in weight_swap_jobs + ] + + # Copy weights to staging buffers and record events + event_b = None + for sbuf_a, sbuf_b, (module_to_cpu, module_to_cuda, cuda_data_view, cpu_data_view) in zip( + self.staging_buffer_a, self.staging_buffer_b, weight_swap_jobs + ): + # CUDA to staging buffer A, non-blocking copy + event_a = torch.cuda.Event() + with T.section("cuda to staging A"): + sbuf_a.copy_(cuda_data_view.data, non_blocking=True) + event_a.record(stream) + + # Wait for staging buffer B to be ready + if event_b is not None: + with T.section("wait staging B"): + event_b.synchronize() # synchronize is needed to wait CPU process. wait_event does not work here because it waits on GPU side only + + # CPU to staging buffer B, CPU to pinned CPU, synchronous copy. Can overlap with CUDA to staging buffer A + with T.section("cpu to staging B"): + # Making this multithreaded does not help, and 'non_blocking=True' does not help either. + sbuf_b.copy_(module_to_cuda.weight.data) # BOTTLENECK + + # Wait for staging buffer A to be ready, and CUDA data view can be reused + with T.section("wait staging A"): + event_a.synchronize() + + # Staging buffer B to CUDA, non-blocking copy. + event_b = torch.cuda.Event() + with T.section("staging B to CUDA"): + cuda_data_view.copy_(sbuf_b, non_blocking=True) + event_b.record(stream) + + # Staging buffer A to CPU, synchronous copy. Can overlap with staging buffer B to CUDA + with T.section("staging A to CPU"): + cpu_data_view.copy_(sbuf_a) # BOTTLENECK + + for sbuf_a, sbuf_b, (module_to_cpu, module_to_cuda, cuda_data_view, cpu_data_view) in zip( + self.staging_buffer_a, self.staging_buffer_b, weight_swap_jobs + ): + # Update references + module_to_cuda.weight.data = cuda_data_view + module_to_cpu.weight.data = cpu_data_view + + sync_event = event_b # final sync event for CPU to CUDA copy + + else: + # Use pinned memory for faster transfer between CPU and GPU, but it requires more memory + if self.pinned_buffer is None: + with torch.cuda.stream(self.stream): + # Create pinned buffer as pinned memory (as shared GPU ram). We specify device for correct pinning on multi-GPU systems + self.pinned_buffer = [ + torch.empty_like(cuda_data_view, device="cpu").pin_memory(device=device) + for _, _, cuda_data_view, _ in weight_swap_jobs + ] + self.stream.synchronize() + released_pinned_buffer = [] + + events = [torch.cuda.Event() for _ in weight_swap_jobs] # Waiting events for GPU to CPU non-blocking copy + + # Copy weights to CPU + for event, module_pin_buf, (module_to_cpu, module_to_cuda, cuda_data_view, cpu_data_view) in zip( + events, self.pinned_buffer, weight_swap_jobs + ): + # CUDA to CPU, non-blocking copy + with torch.cuda.stream(self.stream): + with T.section("cuda to cpu"): + module_pin_buf.copy_(cuda_data_view, non_blocking=True) + event.record(self.stream) + + # CPU to CUDA + for event, (module_to_cpu, module_to_cuda, cuda_data_view, cpu_data_view) in zip(events, weight_swap_jobs): + with torch.cuda.stream(self.stream): + # Wait for cuda_data_view to be ready + with T.section("wait cpu"): + self.stream.wait_event(event) + + # CPU to CUDA, non-blocking copy + with T.section("cpu to cuda"): + cuda_data_view.copy_(cpu_data_view, non_blocking=True) + + # Update references + for module_pin_buf, (module_to_cpu, module_to_cuda, cuda_data_view, cpu_data_view) in zip( + self.pinned_buffer, weight_swap_jobs + ): + module_to_cuda.weight.data = cuda_data_view + module_to_cpu.weight.data = module_pin_buf + released_pinned_buffer.append(cpu_data_view) # CPU data view can be reused as pinned buffer + + # Reuse released pinned buffers + if not released_pinned_buffer[0].is_pinned(): + # In first time, we need to create pinned buffers because offloaded weights are not pinned yet + with torch.cuda.stream(self.stream): + released_pinned_buffer = [ + torch.empty_like(cuda_data_view, device="cpu").pin_memory(device=device) + for _, _, cuda_data_view, _ in weight_swap_jobs + ] + self.pinned_buffer = released_pinned_buffer + + sync_event = self.stream.record_event() + + if debug_print: + print(f"[{self.block_type}] Weight swap timing at {self.debug_block_count - 1}:") + for name, total in T.totals.items(): + print(f" {name}: {total * 1000:.2f}ms") + print( + f"Overall time: {(time.perf_counter() - T.start_time) * 1000:.2f}ms, total time in sections: {sum(T.totals.values()) * 1000:.2f}ms" + ) + # print( + # f"[{self.block_type}] Swapped weights in {time.perf_counter() - start_time:.2f}s. Count of modules swapped: {len(weight_swap_jobs)}" + # ) + + return sync_event + + def swap_weight_devices(self, block_to_cpu: nn.Module, block_to_cuda: nn.Module): + if self.cuda_available: + sync_event = self.swap_weight_devices_cuda(self.device, block_to_cpu, block_to_cuda) + else: + swap_weight_devices_no_cuda(self.device, block_to_cpu, block_to_cuda) + sync_event = None + return sync_event + + def _submit_move_blocks(self, blocks, block_idx_to_cpu, block_idx_to_cuda): + def move_blocks(bidx_to_cpu, block_to_cpu, bidx_to_cuda, block_to_cuda): + if self.debug: + start_time = time.perf_counter() + print( + f"[{self.block_type}] Move block {bidx_to_cpu} to CPU and block {bidx_to_cuda} to {'CUDA' if self.cuda_available else 'device'}" + ) + + dev = self.device.index if self.device.index is not None else torch.cuda.current_device() + torch.cuda.set_device(dev) + + sync_event = self.swap_weight_devices(block_to_cpu, block_to_cuda) + + if self.debug: + print( + f"[{self.block_type}] Moved blocks {bidx_to_cpu} to CPU and {bidx_to_cuda} to {'CUDA' if self.cuda_available else 'device'} in {time.perf_counter() - start_time:.2f}s" + ) + return bidx_to_cpu, bidx_to_cuda, sync_event + + block_to_cpu = blocks[block_idx_to_cpu] + block_to_cuda = blocks[block_idx_to_cuda] + + self.futures[block_idx_to_cuda] = self.thread_pool.submit( + move_blocks, block_idx_to_cpu, block_to_cpu, block_idx_to_cuda, block_to_cuda + ) + + def _wait_blocks_move(self, block_idx): + if block_idx not in self.futures: + return + + if self.debug: + print(f"[{self.block_type}] Wait for block {block_idx}") + start_time = time.perf_counter() + + future = self.futures.pop(block_idx) + _, bidx_to_cuda, sync_event = future.result() + + assert block_idx == bidx_to_cuda, f"Block index mismatch: {block_idx} != {bidx_to_cuda}" + + if self.cuda_available and sync_event is not None: + # this does not wait CPU side, so the log below should be immediate when pinned memory is used + torch.cuda.current_stream().wait_event(sync_event) + + if self.debug: + print(f"[{self.block_type}] Waited for block {block_idx}: {time.perf_counter() - start_time:.2f}s") + + +class ModelOffloader(Offloader): + """ + supports forward offloading + """ + + def __init__( + self, + block_type: str, + blocks: list[nn.Module], + num_blocks: int, + blocks_to_swap: int, + supports_backward: bool, + device: torch.device, + use_pinned_memory: bool = False, + debug: bool = False, + ): + super().__init__(block_type, num_blocks, blocks_to_swap, device, use_pinned_memory, debug) + + self.supports_backward = supports_backward + self.forward_only = not supports_backward # forward only offloading: can be changed to True for inference + + if self.supports_backward: + # register backward hooks + self.remove_handles = [] + for i, block in enumerate(blocks): + hook = self.create_backward_hook(blocks, i) + if hook is not None: + handle = block.register_full_backward_hook(hook) + self.remove_handles.append(handle) + + def set_forward_only(self, forward_only: bool): + # switching must wait for all pending transfers + for block_idx in list(self.futures.keys()): + self._wait_blocks_move(block_idx) + + self.forward_only = forward_only + + def __del__(self): + if self.supports_backward: + for handle in self.remove_handles: + handle.remove() + + def create_backward_hook(self, blocks: list[nn.Module], block_index: int) -> Optional[callable]: + # -1 for 0-based index + num_blocks_propagated = self.num_blocks - block_index - 1 + swapping = num_blocks_propagated > 0 and num_blocks_propagated <= self.blocks_to_swap + waiting = block_index > 0 and block_index <= self.blocks_to_swap + + if not swapping and not waiting: + return None + + # create hook + block_idx_to_cpu = self.num_blocks - num_blocks_propagated + block_idx_to_cuda = self.blocks_to_swap - num_blocks_propagated + block_idx_to_wait = block_index - 1 + + def backward_hook(module, grad_input, grad_output): + if self.debug: + print(f"Backward hook for block {block_index}") + + if swapping: + self._submit_move_blocks(blocks, block_idx_to_cpu, block_idx_to_cuda) + if waiting: + self._wait_blocks_move(block_idx_to_wait) + return None + + return backward_hook + + def prepare_block_devices_before_forward(self, blocks: list[nn.Module]): + if self.blocks_to_swap is None or self.blocks_to_swap == 0: + return + + if self.debug: + print(f"[{self.block_type}] Prepare block devices before forward") + + for b in blocks[0 : self.num_blocks - self.blocks_to_swap]: + b.to(self.device) + weighs_to_device(b, self.device) # make sure weights are on device + + cpu_device = torch.device("cpu") + for b in blocks[self.num_blocks - self.blocks_to_swap :]: + b.to(self.device) # move block to device first. this makes sure that buffers (non weights) are on the device + weighs_to_device(b, cpu_device) # make sure weights are on cpu + + _synchronize_device(self.device) + _clean_memory_on_device(self.device) + + def wait_for_block(self, block_idx: int): + if self.blocks_to_swap is None or self.blocks_to_swap == 0: + return + self._wait_blocks_move(block_idx) + + def submit_move_blocks_forward(self, blocks: list[nn.Module], block_idx: int): + # check if blocks_to_swap is enabled + if self.blocks_to_swap is None or self.blocks_to_swap == 0: + return + + if not self.forward_only: + # if backward is enabled, we do not swap blocks in forward pass more than blocks_to_swap, because it should be on GPU + if block_idx >= self.blocks_to_swap: + return + block_idx_to_cpu = block_idx + block_idx_to_cuda = self.num_blocks - self.blocks_to_swap + block_idx + block_idx_to_cuda = block_idx_to_cuda % self.num_blocks # this does nothing for backward offloading + self._submit_move_blocks(blocks, block_idx_to_cpu, block_idx_to_cuda) + return + + # We use two strategies here for forward-only offloading: + # 1. If blocks_to_swap is less than half of num_blocks, we swap the num_blocks blocks without wrapping around. + # This reduces the number of swaps, so it is especially useful for small blocks_to_swap or lightweight models like Qwen-Image + # 2. If blocks_to_swap is more than half of num_blocks, we swap the blocks with wrapping around. + # This is the common strategy used in most offloading implementations. It transfers all blocks in a wrapping manner. + # This is useful for large blocks_to_swap or heavyweight models like Wan/HunyuanVideo, where the transfer time is less significant compared to computation time. + + # current block to swap out (to CPU) + block_idx_to_cpu = block_idx + + if self.blocks_to_swap < (self.num_blocks // 2): + # strategy 1: no wrap around + # If the current block is in the middle blocks that are not swapped, do nothing + if self.blocks_to_swap <= block_idx < self.num_blocks - self.blocks_to_swap: + return + if block_idx < self.blocks_to_swap: + # move the next block to cuda + block_idx_to_cuda = (self.num_blocks - self.blocks_to_swap + block_idx) % self.num_blocks + else: + # move the previous block to cuda + block_idx_to_cuda = block_idx - (self.num_blocks - self.blocks_to_swap) + else: + # strategy 2: with wrap around + block_idx_to_cuda = self.num_blocks - self.blocks_to_swap + block_idx + block_idx_to_cuda = block_idx_to_cuda % self.num_blocks # this works for forward-only offloading + + self._submit_move_blocks(blocks, block_idx_to_cpu, block_idx_to_cuda) diff --git a/src/musubi_tuner/modules/loftq_init.py b/src/musubi_tuner/modules/loftq_init.py new file mode 100644 index 0000000000000000000000000000000000000000..e1f888d6f7e02b2f266e636d3027d34828d45a0f --- /dev/null +++ b/src/musubi_tuner/modules/loftq_init.py @@ -0,0 +1,73 @@ +"""LoftQ initialization for LoRA + NF4 quantization. + +Pre-computes LoRA A/B matrices that compensate for NF4 quantization error via +truncated SVD of the residual ``W - dequant(Q(W))``. This yields better quality +than random LoRA init when training on a heavily-quantized base model. + +Reference: Li et al., "LoftQ: LoRA-Fine-Tuning-Aware Quantization" (2023). +""" + +from typing import Callable, Tuple + +import torch + +import logging + +logger = logging.getLogger(__name__) + + +@torch.no_grad() +def loftq_initialize( + weight: torch.Tensor, + quantize_fn: Callable, + dequantize_fn: Callable, + lora_rank: int, + block_size: int = 64, + num_iterations: int = 1, + device: torch.device = None, +) -> Tuple[torch.Tensor, torch.Tensor]: + """Compute LoftQ-initialized LoRA matrices for a single weight. + + Args: + weight: ``[out_features, in_features]`` full-precision original weight. + quantize_fn: ``quantize_nf4_block(tensor, block_size) -> (packed, scale)``. + dequantize_fn: ``dequantize_nf4_block(packed, scale, out, in, bs, dtype) -> tensor``. + lora_rank: target LoRA rank (``network_dim``). + block_size: NF4 block size. + num_iterations: number of alternating quantize-SVD iterations (1 is usually enough). + device: device for SVD computation (GPU recommended). + + Returns: + ``(lora_A, lora_B)`` — tensors of shape ``[rank, in]`` and ``[out, rank]``. + """ + out_features, in_features = weight.shape + W = weight.float() + if device is not None: + W = W.to(device) + + # Initial quantize → dequantize + packed, scale = quantize_fn(W, block_size) + W_q = dequantize_fn(packed, scale, out_features, in_features, block_size, torch.float32) + + lora_A = None + lora_B = None + + for i in range(num_iterations): + residual = W - W_q + + # Use randomized low-rank SVD — only computes top-k singular values. + # Orders of magnitude faster than full SVD for large matrices. + U, S, V = torch.svd_lowrank(residual, q=lora_rank) + # U: [out, rank], S: [rank], V: [in, rank] + + sqrt_S = S.sqrt() + lora_B = U * sqrt_S # [out, rank] + lora_A = (V * sqrt_S).T # [rank, in] + + if i < num_iterations - 1: + # Refine: re-quantize W - B@A and recompute residual + approx = W - lora_B @ lora_A + packed, scale = quantize_fn(approx, block_size) + W_q = dequantize_fn(packed, scale, out_features, in_features, block_size, torch.float32) + + return lora_A, lora_B diff --git a/src/musubi_tuner/modules/lr_schedulers.py b/src/musubi_tuner/modules/lr_schedulers.py new file mode 100644 index 0000000000000000000000000000000000000000..61edb04f9dfebcf8e2930a377350aa3742d19e79 --- /dev/null +++ b/src/musubi_tuner/modules/lr_schedulers.py @@ -0,0 +1,67 @@ +import torch + + +class RexLR(torch.optim.lr_scheduler.LRScheduler): + """ + Reflected Exponential (REX) learning rate scheduler (https://arxiv.org/abs/2107.04197) + Modified from: https://github.com/IvanVassi/REX_LR (Apache-2.0 License) + + Args: + optimizer (torch.optim.Optimizer): The optimizer to schedule the learning rate for + max_lr (float): The maximum learning rate + min_lr (float): The minimum learning rate + num_steps (int): The total number of training steps + num_warmup_steps (int): The number of warmup steps + rex_alpha (float): Constant added to the denominator of the REX factor; + prevents division-by-zero and softens the initial decay (default: 0.1). + rex_beta (float): Multiplier of z in the denominator of the REX factor; + controls how quickly the decay flattens as z increases (default: 0.9). + last_epoch (int): The index of the last step + """ + + def __init__(self, optimizer, max_lr, min_lr=0.0, num_steps=0, num_warmup_steps=0, rex_alpha=0.1, rex_beta=0.9, last_epoch=-1): + if min_lr > max_lr: + raise ValueError(f'Value of "min_lr" should be less than value of "max_lr". Got min_lr={min_lr} and max_lr={max_lr}') + if num_warmup_steps > num_steps: + raise ValueError(f"num_warmup_steps ({num_warmup_steps}) must be less than or equal to num_steps ({num_steps})") + + self.min_lr = min_lr + self.max_lr = max_lr + self.num_steps = num_steps + self.num_warmup_steps = num_warmup_steps + self.rex_alpha = rex_alpha + self.rex_beta = rex_beta + self.last_epoch = last_epoch + + # Ensure each parameter group has an "initial_lr" key to avoid issues when resuming + for group in optimizer.param_groups: + group.setdefault("initial_lr", group["lr"]) + + super().__init__(optimizer, last_epoch) + + def get_lr(self): + # Single warmup step + if self.num_warmup_steps == 1 and self.last_epoch == 1: + return [self.min_lr for _ in self.base_lrs] + # Multiple warmup steps; increase lr linearly from min_lr to max_lr + elif self.num_warmup_steps > 1 and self.last_epoch >= 1 and self.last_epoch <= (self.num_warmup_steps - 1): + return [ + self.min_lr + (self.max_lr - self.min_lr) * (self.last_epoch - 1) / (self.num_warmup_steps - 1) + for _ in self.base_lrs + ] + + # Post-warmup phase: adjust step relative to the end of warmup + step_after = self.last_epoch - self.num_warmup_steps + remaining_steps = self.num_steps - self.num_warmup_steps + + # Avoid LR spiking + if step_after >= remaining_steps or step_after == -1 or remaining_steps <= 0: + return [self.min_lr for _ in self.base_lrs] + + # Calculate REX curve for current step + rex_z = (remaining_steps - (step_after % remaining_steps)) / remaining_steps + rex_factor = self.min_lr / self.max_lr + (1.0 - self.min_lr / self.max_lr) * ( + rex_z / (self.rex_alpha + self.rex_beta * rex_z) + ) + + return [base_lr * rex_factor for base_lr in self.base_lrs] diff --git a/src/musubi_tuner/modules/nf4_optimization_utils.py b/src/musubi_tuner/modules/nf4_optimization_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ee58dcd7862b70f92c8dab5277863fa9830b9dad --- /dev/null +++ b/src/musubi_tuner/modules/nf4_optimization_utils.py @@ -0,0 +1,418 @@ +"""NF4 (4-bit NormalFloat) quantization utilities for base model compression. + +Parallel to fp8_optimization_utils.py — provides quantize/dequantize, monkey-patching, +and safetensors loading with NF4 quantization. + +The NF4 codebook is the set of 16 values that are optimal for normally-distributed +weights (as derived in the QLoRA paper). Weights are stored as packed uint8 (two +4-bit indices per byte) with per-block absmax scales. +""" + +import os +from typing import List, Optional, Tuple, Union + +import torch +import torch.nn as nn +import torch.nn.functional as F + +import logging + +from tqdm import tqdm + +from musubi_tuner.utils.safetensors_utils import MemoryEfficientSafeOpen, TensorWeightAdapter, WeightTransformHooks +from musubi_tuner.utils.device_utils import clean_memory_on_device + +logger = logging.getLogger(__name__) + +# --------------------------------------------------------------------------- +# NF4 codebook (16 values, symmetric around 0, optimal for N(0,1) weights) +# --------------------------------------------------------------------------- +NF4_CODEBOOK = torch.tensor( + [ + -1.0, + -0.6961928009986877, + -0.5250730514526367, + -0.39491748809814453, + -0.28444138169288635, + -0.18477343022823334, + -0.09105003625154495, + 0.0, + 0.07958029955625534, + 0.16093020141124725, + 0.24611230194568634, + 0.33791524171829224, + 0.44070982933044434, + 0.5626170039176941, + 0.7229568362236023, + 1.0, + ], + dtype=torch.float32, +) + +DEFAULT_NF4_BLOCK_SIZE = 32 + + +# --------------------------------------------------------------------------- +# Pack / unpack helpers +# --------------------------------------------------------------------------- + +def pack_uint4(indices: torch.Tensor) -> torch.Tensor: + """Pack pairs of 4-bit indices into uint8. ``indices`` must have even length.""" + assert indices.numel() % 2 == 0, "Number of elements must be even for uint4 packing" + flat = indices.view(-1) + high = flat[0::2].to(torch.uint8) + low = flat[1::2].to(torch.uint8) + return (high << 4) | low + + +def unpack_uint4(packed: torch.Tensor, num_elements: int) -> torch.Tensor: + """Unpack uint8 → pairs of 4-bit indices. Returns ``[num_elements]`` uint8.""" + flat = packed.view(-1) + high = (flat >> 4) & 0x0F + low = flat & 0x0F + # interleave: [h0, l0, h1, l1, ...] + out = torch.stack([high, low], dim=1).view(-1) + return out[:num_elements].to(torch.uint8) + + +# --------------------------------------------------------------------------- +# Quantize / dequantize +# --------------------------------------------------------------------------- + +def quantize_nf4_block( + tensor: torch.Tensor, + block_size: int = DEFAULT_NF4_BLOCK_SIZE, +) -> Tuple[torch.Tensor, torch.Tensor]: + """Quantize a 2-D weight tensor to NF4 with per-block absmax scaling. + + Args: + tensor: ``[out_features, in_features]`` float weight. + block_size: number of elements per quantization block. + + Returns: + packed_weight: ``[out_features, in_features // 2]`` uint8 (two indices per byte). + scale: ``[out_features, num_blocks, 1]`` float32 absmax per block. + """ + assert tensor.ndim == 2, f"Expected 2-D tensor, got {tensor.ndim}-D" + out_features, in_features = tensor.shape + if in_features % block_size != 0: + raise ValueError( + f"in_features ({in_features}) must be divisible by block_size ({block_size})" + ) + num_blocks = in_features // block_size + + # Reshape to [out, num_blocks, block_size] + t = tensor.float().contiguous().view(out_features, num_blocks, block_size) + + # Per-block absmax scale + scale = t.abs().amax(dim=2, keepdim=True).clamp_(min=1e-8) # [out, num_blocks, 1] + + # Normalize to [-1, 1] + normalized = t / scale # [out, num_blocks, block_size] + + # Find nearest codebook entry using bucketize (O(N) memory, not O(N*16)). + # The codebook is sorted, so we compute midpoints between consecutive values + # and use bucketize to find which bin each normalized value falls into. + codebook = NF4_CODEBOOK.to(normalized.device) # [16] + # Midpoints between consecutive codebook values → 15 boundaries + midpoints = (codebook[:-1] + codebook[1:]) / 2.0 # [15] + flat_norm = normalized.reshape(-1) # [N] + indices = torch.bucketize(flat_norm, midpoints) # [N] int64, values in [0, 15] + + # Reshape indices back and pack + indices = indices.view(out_features, in_features) # [out, in] + packed = pack_uint4(indices).view(out_features, in_features // 2) + + return packed, scale.to(torch.float32) + + +def dequantize_nf4_block( + packed_weight: torch.Tensor, + scale: torch.Tensor, + out_features: int, + in_features: int, + block_size: int = DEFAULT_NF4_BLOCK_SIZE, + dtype: torch.dtype = torch.bfloat16, +) -> torch.Tensor: + """Dequantize NF4-packed weight back to a dense float tensor. + + Args: + packed_weight: ``[out_features, in_features // 2]`` uint8. + scale: ``[out_features, num_blocks, 1]`` float32. + out_features, in_features: original weight shape. + block_size: must match quantization block size. + dtype: output dtype (e.g. bfloat16). + + Returns: + ``[out_features, in_features]`` tensor in *dtype*. + """ + num_blocks = in_features // block_size + codebook = NF4_CODEBOOK.to(scale.device) # [16] + + indices = unpack_uint4(packed_weight, out_features * in_features) + indices = indices.to(scale.device).long() + values = codebook[indices] # float32 + + values = values.view(out_features, num_blocks, block_size) + values = values * scale # broadcast [out, num_blocks, 1] + values = values.view(out_features, in_features) + return values.to(dtype) + + +# --------------------------------------------------------------------------- +# State-dict-level quantization (mirrors optimize_state_dict_with_fp8) +# --------------------------------------------------------------------------- + +def optimize_state_dict_with_nf4( + state_dict: dict, + calc_device: Union[str, torch.device], + target_layer_keys: Optional[List[str]] = None, + exclude_layer_keys: Optional[List[str]] = None, + block_size: int = DEFAULT_NF4_BLOCK_SIZE, + move_to_device: bool = False, +) -> dict: + """Quantize target Linear weights in *state_dict* to NF4 in-place. + + For each target ``.weight`` key the dict is updated with: + * original key → packed uint8 weight ``[out, in//2]`` + * ``.scale_weight`` → per-block scale ``[out, num_blocks, 1]`` + * ``.nf4_shape`` → ``torch.tensor([out, in])`` (original shape) + """ + optimized_count = 0 + + target_keys_list = [] + for key in list(state_dict.keys()): + is_target = ( + target_layer_keys is None or any(p in key for p in target_layer_keys) + ) and key.endswith(".weight") + is_excluded = exclude_layer_keys is not None and any( + p in key for p in exclude_layer_keys + ) + if is_target and not is_excluded and isinstance(state_dict[key], torch.Tensor): + target_keys_list.append(key) + + for key in tqdm(target_keys_list, desc="NF4 quantizing"): + value = state_dict[key] + if value.ndim != 2: + continue # skip non-2D (e.g. bias, norm) + out_features, in_features = value.shape + if in_features % block_size != 0: + logger.warning( + "Skipping NF4 for %s: in_features=%d not divisible by block_size=%d", + key, + in_features, + block_size, + ) + continue + + original_device = value.device + original_dtype = value.dtype + if calc_device is not None: + value = value.to(calc_device) + + packed, scale = quantize_nf4_block(value, block_size) + + target_device = calc_device if (calc_device is not None and move_to_device) else original_device + state_dict[key] = packed.to(target_device) + state_dict[key.replace(".weight", ".scale_weight")] = scale.to( + dtype=original_dtype, device=target_device + ) + state_dict[key.replace(".weight", ".nf4_shape")] = torch.tensor( + [out_features, in_features], dtype=torch.int64 + ) + + optimized_count += 1 + if calc_device is not None and optimized_count % 10 == 0: + clean_memory_on_device(calc_device) + + logger.info(f"Number of NF4-quantized Linear layers: {optimized_count}") + return state_dict + + +def load_safetensors_with_nf4_optimization( + model_files: List[str], + calc_device: Union[str, torch.device], + target_layer_keys: Optional[List[str]] = None, + exclude_layer_keys: Optional[List[str]] = None, + block_size: int = DEFAULT_NF4_BLOCK_SIZE, + move_to_device: bool = False, + weight_hook=None, + disable_numpy_memmap: bool = False, + weight_transform_hooks: Optional[WeightTransformHooks] = None, +) -> dict: + """Load safetensors and quantize target layers to NF4. + + Mirrors ``load_safetensors_with_fp8_optimization``. + """ + + def is_target_key(key): + is_target = ( + target_layer_keys is None or any(p in key for p in target_layer_keys) + ) and key.endswith(".weight") + is_excluded = exclude_layer_keys is not None and any( + p in key for p in exclude_layer_keys + ) + return is_target and not is_excluded + + optimized_count = 0 + state_dict: dict = {} + + for model_file in model_files: + with MemoryEfficientSafeOpen(model_file, disable_numpy_memmap=disable_numpy_memmap) as original_f: + f = ( + TensorWeightAdapter(weight_transform_hooks, original_f) + if weight_transform_hooks is not None + else original_f + ) + keys = f.keys() + for key in tqdm(keys, desc=f"Loading {os.path.basename(model_file)}", unit="key"): + value = f.get_tensor(key) + original_device = value.device + + if weight_hook is not None: + value = weight_hook(key, value, keep_on_calc_device=(calc_device is not None)) + + if not is_target_key(key) or value.ndim != 2: + target_device = calc_device if (calc_device is not None and move_to_device) else original_device + state_dict[key] = value.to(target_device) + continue + + out_features, in_features = value.shape + if in_features % block_size != 0: + logger.warning( + "Skipping NF4 for %s: in_features=%d not divisible by block_size=%d", + key, + in_features, + block_size, + ) + target_device = calc_device if (calc_device is not None and move_to_device) else original_device + state_dict[key] = value.to(target_device) + continue + + if calc_device is not None: + value = value.to(calc_device) + + original_dtype = value.dtype + packed, scale = quantize_nf4_block(value, block_size) + + target_device = calc_device if (calc_device is not None and move_to_device) else original_device + state_dict[key] = packed.to(target_device) + state_dict[key.replace(".weight", ".scale_weight")] = scale.to( + dtype=original_dtype, device=target_device + ) + state_dict[key.replace(".weight", ".nf4_shape")] = torch.tensor( + [out_features, in_features], dtype=torch.int64 + ) + + optimized_count += 1 + if calc_device is not None and optimized_count % 10 == 0: + clean_memory_on_device(calc_device) + + logger.info(f"Number of NF4-quantized Linear layers: {optimized_count}") + return state_dict + + +# --------------------------------------------------------------------------- +# Monkey-patched forward +# --------------------------------------------------------------------------- + +def nf4_linear_forward_patch(self: nn.Linear, x: torch.Tensor) -> torch.Tensor: + """Drop-in replacement forward for NF4-quantized Linear layers.""" + w = dequantize_nf4_block( + self.weight, + self.scale_weight, + self.nf4_out_features, + self.nf4_in_features, + self.nf4_block_size, + self.scale_weight.dtype, + ) + if hasattr(self, "awq_scales"): + # Un-scale columns: divide by the AWQ scales that were multiplied before quantization + w = w / self.awq_scales.unsqueeze(0) # [1, in] broadcast over [out, in] + w = w.to(self.scale_weight.dtype) + return F.linear(x, w, self.bias) + + +def apply_nf4_monkey_patch( + model: nn.Module, + optimized_state_dict: dict, + block_size: int = DEFAULT_NF4_BLOCK_SIZE, + awq_scales: Optional[dict] = None, +) -> nn.Module: + """Register NF4 buffers and replace forward on quantized Linears. + + Mirrors ``apply_fp8_monkey_patch``. + + Args: + awq_scales: Optional dict mapping module_name -> scale tensor [in_features]. + If provided, each patched module gets an ``awq_scales`` buffer for + un-scaling during the forward pass. + """ + # Identify NF4-quantized modules from the state dict + shape_keys = [k for k in optimized_state_dict if k.endswith(".nf4_shape")] + patched_module_paths: set = set() + shape_info: dict = {} + scale_shape_info: dict = {} + for shape_key in shape_keys: + module_path = shape_key.rsplit(".nf4_shape", 1)[0] + patched_module_paths.add(module_path) + shape_tensor = optimized_state_dict[shape_key] + shape_info[module_path] = (int(shape_tensor[0].item()), int(shape_tensor[1].item())) + scale_key = module_path + ".scale_weight" + scale_shape_info[module_path] = optimized_state_dict[scale_key].shape + + patched_count = 0 + for name, module in model.named_modules(): + if name not in patched_module_paths: + continue + if not isinstance(module, nn.Linear): + continue + + out_f, in_f = shape_info[name] + scale_shape = scale_shape_info[name] + packed_shape = (out_f, in_f // 2) + + # Replace weight parameter with a buffer of packed shape so + # load_state_dict(assign=True) doesn't complain about shape mismatch. + weight_dtype = module.weight.dtype if module.weight.dtype != torch.float32 else torch.uint8 + del module.weight + module.register_buffer("weight", torch.zeros(packed_shape, dtype=torch.uint8)) + + # Register buffers so load_state_dict can assign them + module.register_buffer("scale_weight", torch.ones(scale_shape, dtype=weight_dtype)) + module.register_buffer("nf4_shape", torch.zeros(2, dtype=torch.int64)) + + # Store metadata as plain attributes + module.nf4_out_features = out_f + module.nf4_in_features = in_f + module.nf4_block_size = block_size + module._nf4_quantized = True + + # Register AWQ scales buffer if available + if awq_scales is not None: + # AWQ scales are keyed by weight key (e.g. "layer.weight") + weight_key = name + ".weight" + if weight_key in awq_scales: + module.register_buffer( + "awq_scales", + awq_scales[weight_key].to(dtype=torch.float32), + ) + + # Replace forward + def new_forward(self, x): + return nf4_linear_forward_patch(self, x) + + module.forward = new_forward.__get__(module, type(module)) + patched_count += 1 + + logger.info(f"Number of NF4 monkey-patched Linear layers: {patched_count}") + return model + + +# --------------------------------------------------------------------------- +# Detection helper +# --------------------------------------------------------------------------- + +def is_nf4_module(module: nn.Module) -> bool: + """Check whether *module* has been NF4-quantized (attribute-based, not dtype).""" + return getattr(module, "_nf4_quantized", False) diff --git a/src/musubi_tuner/modules/scheduling_flow_match_discrete.py b/src/musubi_tuner/modules/scheduling_flow_match_discrete.py new file mode 100644 index 0000000000000000000000000000000000000000..c507ec4eb050463188e250c20aec8d1fde2c4a5d --- /dev/null +++ b/src/musubi_tuner/modules/scheduling_flow_match_discrete.py @@ -0,0 +1,257 @@ +# Copyright 2024 Stability AI, Katherine Crowson and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +# +# Modified from diffusers==0.29.2 +# +# ============================================================================== + +from dataclasses import dataclass +from typing import Optional, Tuple, Union + +import numpy as np +import torch + +from diffusers.configuration_utils import ConfigMixin, register_to_config +from diffusers.utils import BaseOutput, logging +from diffusers.schedulers.scheduling_utils import SchedulerMixin + + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +@dataclass +class FlowMatchDiscreteSchedulerOutput(BaseOutput): + """ + Output class for the scheduler's `step` function output. + + Args: + prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images): + Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the + denoising loop. + """ + + prev_sample: torch.FloatTensor + + +class FlowMatchDiscreteScheduler(SchedulerMixin, ConfigMixin): + """ + Euler scheduler. + + This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic + methods the library implements for all schedulers such as loading and saving. + + Args: + num_train_timesteps (`int`, defaults to 1000): + The number of diffusion steps to train the model. + timestep_spacing (`str`, defaults to `"linspace"`): + The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and + Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information. + shift (`float`, defaults to 1.0): + The shift value for the timestep schedule. + reverse (`bool`, defaults to `True`): + Whether to reverse the timestep schedule. + """ + + _compatibles = [] + order = 1 + + @register_to_config + def __init__( + self, + num_train_timesteps: int = 1000, + shift: float = 1.0, + reverse: bool = True, + solver: str = "euler", + n_tokens: Optional[int] = None, + ): + sigmas = torch.linspace(1, 0, num_train_timesteps + 1) + + if not reverse: + sigmas = sigmas.flip(0) + + self.sigmas = sigmas + # the value fed to model + self.timesteps = (sigmas[:-1] * num_train_timesteps).to(dtype=torch.float32) + + self._step_index = None + self._begin_index = None + + self.supported_solver = ["euler"] + if solver not in self.supported_solver: + raise ValueError( + f"Solver {solver} not supported. Supported solvers: {self.supported_solver}" + ) + + @property + def step_index(self): + """ + The index counter for current timestep. It will increase 1 after each scheduler step. + """ + return self._step_index + + @property + def begin_index(self): + """ + The index for the first timestep. It should be set from pipeline with `set_begin_index` method. + """ + return self._begin_index + + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index + def set_begin_index(self, begin_index: int = 0): + """ + Sets the begin index for the scheduler. This function should be run from pipeline before the inference. + + Args: + begin_index (`int`): + The begin index for the scheduler. + """ + self._begin_index = begin_index + + def _sigma_to_t(self, sigma): + return sigma * self.config.num_train_timesteps + + def set_timesteps( + self, + num_inference_steps: int, + device: Union[str, torch.device] = None, + n_tokens: int = None, + ): + """ + Sets the discrete timesteps used for the diffusion chain (to be run before inference). + + Args: + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + n_tokens (`int`, *optional*): + Number of tokens in the input sequence. + """ + self.num_inference_steps = num_inference_steps + + sigmas = torch.linspace(1, 0, num_inference_steps + 1) + sigmas = self.sd3_time_shift(sigmas) + + if not self.config.reverse: + sigmas = 1 - sigmas + + self.sigmas = sigmas + self.timesteps = (sigmas[:-1] * self.config.num_train_timesteps).to( + dtype=torch.float32, device=device + ) + + # Reset step index + self._step_index = None + + def index_for_timestep(self, timestep, schedule_timesteps=None): + if schedule_timesteps is None: + schedule_timesteps = self.timesteps + + indices = (schedule_timesteps == timestep).nonzero() + + # The sigma index that is taken for the **very** first `step` + # is always the second index (or the last index if there is only 1) + # This way we can ensure we don't accidentally skip a sigma in + # case we start in the middle of the denoising schedule (e.g. for image-to-image) + pos = 1 if len(indices) > 1 else 0 + + return indices[pos].item() + + def _init_step_index(self, timestep): + if self.begin_index is None: + if isinstance(timestep, torch.Tensor): + timestep = timestep.to(self.timesteps.device) + self._step_index = self.index_for_timestep(timestep) + else: + self._step_index = self._begin_index + + def scale_model_input( + self, sample: torch.Tensor, timestep: Optional[int] = None + ) -> torch.Tensor: + return sample + + def sd3_time_shift(self, t: torch.Tensor): + return (self.config.shift * t) / (1 + (self.config.shift - 1) * t) + + def step( + self, + model_output: torch.FloatTensor, + timestep: Union[float, torch.FloatTensor], + sample: torch.FloatTensor, + return_dict: bool = True, + ) -> Union[FlowMatchDiscreteSchedulerOutput, Tuple]: + """ + Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion + process from the learned model outputs (most often the predicted noise). + + Args: + model_output (`torch.FloatTensor`): + The direct output from learned diffusion model. + timestep (`float`): + The current discrete timestep in the diffusion chain. + sample (`torch.FloatTensor`): + A current instance of a sample created by the diffusion process. + generator (`torch.Generator`, *optional*): + A random number generator. + n_tokens (`int`, *optional*): + Number of tokens in the input sequence. + return_dict (`bool`): + Whether or not to return a [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or + tuple. + + Returns: + [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or `tuple`: + If return_dict is `True`, [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] is + returned, otherwise a tuple is returned where the first element is the sample tensor. + """ + + if ( + isinstance(timestep, int) + or isinstance(timestep, torch.IntTensor) + or isinstance(timestep, torch.LongTensor) + ): + raise ValueError( + ( + "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to" + " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass" + " one of the `scheduler.timesteps` as a timestep." + ), + ) + + if self.step_index is None: + self._init_step_index(timestep) + + # Upcast to avoid precision issues when computing prev_sample + sample = sample.to(torch.float32) + + dt = self.sigmas[self.step_index + 1] - self.sigmas[self.step_index] + + if self.config.solver == "euler": + prev_sample = sample + model_output.to(torch.float32) * dt + else: + raise ValueError( + f"Solver {self.config.solver} not supported. Supported solvers: {self.supported_solver}" + ) + + # upon completion increase step index by one + self._step_index += 1 + + if not return_dict: + return (prev_sample,) + + return FlowMatchDiscreteSchedulerOutput(prev_sample=prev_sample) + + def __len__(self): + return self.config.num_train_timesteps diff --git a/src/musubi_tuner/modules/unet_causal_3d_blocks.py b/src/musubi_tuner/modules/unet_causal_3d_blocks.py new file mode 100644 index 0000000000000000000000000000000000000000..27d544170ece6a370cdacfe9e31367b884c2e516 --- /dev/null +++ b/src/musubi_tuner/modules/unet_causal_3d_blocks.py @@ -0,0 +1,818 @@ +# Copyright 2024 The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ============================================================================== +# +# Modified from diffusers==0.29.2 +# +# ============================================================================== + +from typing import Optional, Tuple, Union + +import torch +import torch.nn.functional as F +from torch import nn +from einops import rearrange + +from diffusers.utils import logging +from diffusers.models.activations import get_activation +from diffusers.models.attention_processor import SpatialNorm +from diffusers.models.attention_processor import Attention +from diffusers.models.normalization import AdaGroupNorm +from diffusers.models.normalization import RMSNorm + +logger = logging.get_logger(__name__) # pylint: disable=invalid-name + + +def prepare_causal_attention_mask(n_frame: int, n_hw: int, dtype, device, batch_size: int = None): + seq_len = n_frame * n_hw + mask = torch.full((seq_len, seq_len), float("-inf"), dtype=dtype, device=device) + for i in range(seq_len): + i_frame = i // n_hw + mask[i, : (i_frame + 1) * n_hw] = 0 + if batch_size is not None: + mask = mask.unsqueeze(0).expand(batch_size, -1, -1) + return mask + + +class CausalConv3d(nn.Module): + """ + Implements a causal 3D convolution layer where each position only depends on previous timesteps and current spatial locations. + This maintains temporal causality in video generation tasks. + """ + + def __init__( + self, + chan_in, + chan_out, + kernel_size: Union[int, Tuple[int, int, int]], + stride: Union[int, Tuple[int, int, int]] = 1, + dilation: Union[int, Tuple[int, int, int]] = 1, + pad_mode="replicate", + chunk_size=0, + **kwargs, + ): + super().__init__() + + self.pad_mode = pad_mode + padding = (kernel_size // 2, kernel_size // 2, kernel_size // 2, kernel_size // 2, kernel_size - 1, 0) # W, H, T + self.time_causal_padding = padding + self.chunk_size = chunk_size + + self.conv = nn.Conv3d(chan_in, chan_out, kernel_size, stride=stride, dilation=dilation, **kwargs) + + def original_forward(self, x): + x = F.pad(x, self.time_causal_padding, mode=self.pad_mode) + return self.conv(x) + + def forward(self, x): + if self.chunk_size == 0: + return self.original_forward(x) + + # if not large, call original forward + if x.shape[4] < self.chunk_size * 1.5: + return self.original_forward(x) + + # # debug: verify the original forward is the same as chunked forward + # orig_forwarded_value = None + # if x.shape[4] < self.chunk_size * 4: + # orig_forwarded_value = self.original_forward(x) + + # get the kernel size + kernel_size = self.conv.kernel_size[0] # assume cubic kernel + assert kernel_size == self.conv.kernel_size[1] == self.conv.kernel_size[2], "Only cubic kernels are supported" + padding_size = kernel_size // 2 # 1 for kernel_size=3, 0 for kernel_size=1 + + x = F.pad(x, self.time_causal_padding, mode=self.pad_mode) + + B, C, D, H, W = orig_shape = x.shape + chunk_size = self.chunk_size + chunk_size -= chunk_size % self.conv.stride[2] # make sure the chunk size is divisible by stride + # print(f"chunked forward: {x.shape}, chunk_size: {chunk_size}") + + # calculate the indices for chunking with overlap and padding by kernel size and stride + indices = [] + i = 0 + while i < W - padding_size: + start_idx = i - padding_size + end_idx = min(i + chunk_size + padding_size, W) + if i == 0: + start_idx = 0 + end_idx += padding_size # to make sure the first chunk is divisible by stride + if W - end_idx < chunk_size // 2: # small chunk at the end + end_idx = W + indices.append((start_idx, end_idx)) + i = end_idx - padding_size + # print(f"chunked forward: {x.shape}, chunked indices: {indices}") + + chunks = [] + for start_idx, end_idx in indices: + chunk = x[:, :, :, :, start_idx:end_idx] + chunk_output = self.conv(chunk) + # print(chunk.shape, chunk_output.shape) + chunks.append(chunk_output) + + # concatenate the chunks + x = torch.cat(chunks, dim=4) + + assert ( + x.shape[2] == ((D - padding_size * 2) + self.conv.stride[0] - 1) // self.conv.stride[0] + ), f"Invalid shape: {x.shape}, {orig_shape}, {padding_size}, {self.conv.stride}" + assert ( + x.shape[3] == ((H - padding_size * 2) + self.conv.stride[1] - 1) // self.conv.stride[1] + ), f"Invalid shape: {x.shape}, {orig_shape}, {padding_size}, {self.conv.stride}" + assert ( + x.shape[4] == ((W - padding_size * 2) + self.conv.stride[2] - 1) // self.conv.stride[2] + ), f"Invalid shape: {x.shape}, {orig_shape}, {padding_size}, {self.conv.stride}" + + # # debug: verify the original forward is the same as chunked forward + # if orig_forwarded_value is not None: + # assert torch.allclose( + # orig_forwarded_value, x, rtol=1e-4, atol=1e-2 + # ), f"Chunked forward is different from original forward. {x.shape}, {orig_shape}, {padding_size}, {self.conv.stride}, {self.conv.kernel_size}" + + return x + + +class UpsampleCausal3D(nn.Module): + """ + A 3D upsampling layer with an optional convolution. + """ + + def __init__( + self, + channels: int, + use_conv: bool = False, + use_conv_transpose: bool = False, + out_channels: Optional[int] = None, + name: str = "conv", + kernel_size: Optional[int] = None, + padding=1, + norm_type=None, + eps=None, + elementwise_affine=None, + bias=True, + interpolate=True, + upsample_factor=(2, 2, 2), + ): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.use_conv_transpose = use_conv_transpose + self.name = name + self.interpolate = interpolate + self.upsample_factor = upsample_factor + + if norm_type == "ln_norm": + self.norm = nn.LayerNorm(channels, eps, elementwise_affine) + elif norm_type == "rms_norm": + self.norm = RMSNorm(channels, eps, elementwise_affine) + elif norm_type is None: + self.norm = None + else: + raise ValueError(f"unknown norm_type: {norm_type}") + + conv = None + if use_conv_transpose: + raise NotImplementedError + elif use_conv: + if kernel_size is None: + kernel_size = 3 + conv = CausalConv3d(self.channels, self.out_channels, kernel_size=kernel_size, bias=bias) + + if name == "conv": + self.conv = conv + else: + self.Conv2d_0 = conv + + def forward( + self, + hidden_states: torch.FloatTensor, + output_size: Optional[int] = None, + scale: float = 1.0, + ) -> torch.FloatTensor: + assert hidden_states.shape[1] == self.channels + + if self.norm is not None: + raise NotImplementedError + + if self.use_conv_transpose: + return self.conv(hidden_states) + + # Cast to float32 to as 'upsample_nearest2d_out_frame' op does not support bfloat16 + dtype = hidden_states.dtype + if dtype == torch.bfloat16: + hidden_states = hidden_states.to(torch.float32) + + # upsample_nearest_nhwc fails with large batch sizes. see https://github.com/huggingface/diffusers/issues/984 + if hidden_states.shape[0] >= 64: + hidden_states = hidden_states.contiguous() + + # if `output_size` is passed we force the interpolation output + # size and do not make use of `scale_factor=2` + if self.interpolate: + B, C, T, H, W = hidden_states.shape + first_h, other_h = hidden_states.split((1, T - 1), dim=2) + if output_size is None: + if T > 1: + other_h = F.interpolate(other_h, scale_factor=self.upsample_factor, mode="nearest") + + first_h = first_h.squeeze(2) + first_h = F.interpolate(first_h, scale_factor=self.upsample_factor[1:], mode="nearest") + first_h = first_h.unsqueeze(2) + else: + raise NotImplementedError + + if T > 1: + hidden_states = torch.cat((first_h, other_h), dim=2) + else: + hidden_states = first_h + + # If the input is bfloat16, we cast back to bfloat16 + if dtype == torch.bfloat16: + hidden_states = hidden_states.to(dtype) + + if self.use_conv: + if self.name == "conv": + hidden_states = self.conv(hidden_states) + else: + hidden_states = self.Conv2d_0(hidden_states) + + return hidden_states + + +class DownsampleCausal3D(nn.Module): + """ + A 3D downsampling layer with an optional convolution. + """ + + def __init__( + self, + channels: int, + use_conv: bool = False, + out_channels: Optional[int] = None, + padding: int = 1, + name: str = "conv", + kernel_size=3, + norm_type=None, + eps=None, + elementwise_affine=None, + bias=True, + stride=2, + ): + super().__init__() + self.channels = channels + self.out_channels = out_channels or channels + self.use_conv = use_conv + self.padding = padding + stride = stride + self.name = name + + if norm_type == "ln_norm": + self.norm = nn.LayerNorm(channels, eps, elementwise_affine) + elif norm_type == "rms_norm": + self.norm = RMSNorm(channels, eps, elementwise_affine) + elif norm_type is None: + self.norm = None + else: + raise ValueError(f"unknown norm_type: {norm_type}") + + if use_conv: + conv = CausalConv3d(self.channels, self.out_channels, kernel_size=kernel_size, stride=stride, bias=bias) + else: + raise NotImplementedError + + if name == "conv": + self.Conv2d_0 = conv + self.conv = conv + elif name == "Conv2d_0": + self.conv = conv + else: + self.conv = conv + + def forward(self, hidden_states: torch.FloatTensor, scale: float = 1.0) -> torch.FloatTensor: + assert hidden_states.shape[1] == self.channels + + if self.norm is not None: + hidden_states = self.norm(hidden_states.permute(0, 2, 3, 1)).permute(0, 3, 1, 2) + + assert hidden_states.shape[1] == self.channels + + hidden_states = self.conv(hidden_states) + + return hidden_states + + +class ResnetBlockCausal3D(nn.Module): + r""" + A Resnet block. + """ + + def __init__( + self, + *, + in_channels: int, + out_channels: Optional[int] = None, + conv_shortcut: bool = False, + dropout: float = 0.0, + temb_channels: int = 512, + groups: int = 32, + groups_out: Optional[int] = None, + pre_norm: bool = True, + eps: float = 1e-6, + non_linearity: str = "swish", + skip_time_act: bool = False, + # default, scale_shift, ada_group, spatial + time_embedding_norm: str = "default", + kernel: Optional[torch.FloatTensor] = None, + output_scale_factor: float = 1.0, + use_in_shortcut: Optional[bool] = None, + up: bool = False, + down: bool = False, + conv_shortcut_bias: bool = True, + conv_3d_out_channels: Optional[int] = None, + ): + super().__init__() + self.pre_norm = pre_norm + self.pre_norm = True + self.in_channels = in_channels + out_channels = in_channels if out_channels is None else out_channels + self.out_channels = out_channels + self.use_conv_shortcut = conv_shortcut + self.up = up + self.down = down + self.output_scale_factor = output_scale_factor + self.time_embedding_norm = time_embedding_norm + self.skip_time_act = skip_time_act + + linear_cls = nn.Linear + + if groups_out is None: + groups_out = groups + + if self.time_embedding_norm == "ada_group": + self.norm1 = AdaGroupNorm(temb_channels, in_channels, groups, eps=eps) + elif self.time_embedding_norm == "spatial": + self.norm1 = SpatialNorm(in_channels, temb_channels) + else: + self.norm1 = torch.nn.GroupNorm(num_groups=groups, num_channels=in_channels, eps=eps, affine=True) + + self.conv1 = CausalConv3d(in_channels, out_channels, kernel_size=3, stride=1) + + if temb_channels is not None: + if self.time_embedding_norm == "default": + self.time_emb_proj = linear_cls(temb_channels, out_channels) + elif self.time_embedding_norm == "scale_shift": + self.time_emb_proj = linear_cls(temb_channels, 2 * out_channels) + elif self.time_embedding_norm == "ada_group" or self.time_embedding_norm == "spatial": + self.time_emb_proj = None + else: + raise ValueError(f"Unknown time_embedding_norm : {self.time_embedding_norm} ") + else: + self.time_emb_proj = None + + if self.time_embedding_norm == "ada_group": + self.norm2 = AdaGroupNorm(temb_channels, out_channels, groups_out, eps=eps) + elif self.time_embedding_norm == "spatial": + self.norm2 = SpatialNorm(out_channels, temb_channels) + else: + self.norm2 = torch.nn.GroupNorm(num_groups=groups_out, num_channels=out_channels, eps=eps, affine=True) + + self.dropout = torch.nn.Dropout(dropout) + conv_3d_out_channels = conv_3d_out_channels or out_channels + self.conv2 = CausalConv3d(out_channels, conv_3d_out_channels, kernel_size=3, stride=1) + + self.nonlinearity = get_activation(non_linearity) + + self.upsample = self.downsample = None + if self.up: + self.upsample = UpsampleCausal3D(in_channels, use_conv=False) + elif self.down: + self.downsample = DownsampleCausal3D(in_channels, use_conv=False, name="op") + + self.use_in_shortcut = self.in_channels != conv_3d_out_channels if use_in_shortcut is None else use_in_shortcut + + self.conv_shortcut = None + if self.use_in_shortcut: + self.conv_shortcut = CausalConv3d( + in_channels, + conv_3d_out_channels, + kernel_size=1, + stride=1, + bias=conv_shortcut_bias, + ) + + def forward( + self, + input_tensor: torch.FloatTensor, + temb: torch.FloatTensor, + scale: float = 1.0, + ) -> torch.FloatTensor: + hidden_states = input_tensor + + if self.time_embedding_norm == "ada_group" or self.time_embedding_norm == "spatial": + hidden_states = self.norm1(hidden_states, temb) + else: + hidden_states = self.norm1(hidden_states) + + hidden_states = self.nonlinearity(hidden_states) + + if self.upsample is not None: + # upsample_nearest_nhwc fails with large batch sizes. see https://github.com/huggingface/diffusers/issues/984 + if hidden_states.shape[0] >= 64: + input_tensor = input_tensor.contiguous() + hidden_states = hidden_states.contiguous() + input_tensor = self.upsample(input_tensor, scale=scale) + hidden_states = self.upsample(hidden_states, scale=scale) + elif self.downsample is not None: + input_tensor = self.downsample(input_tensor, scale=scale) + hidden_states = self.downsample(hidden_states, scale=scale) + + hidden_states = self.conv1(hidden_states) + + if self.time_emb_proj is not None: + if not self.skip_time_act: + temb = self.nonlinearity(temb) + temb = self.time_emb_proj(temb, scale)[:, :, None, None] + + if temb is not None and self.time_embedding_norm == "default": + hidden_states = hidden_states + temb + + if self.time_embedding_norm == "ada_group" or self.time_embedding_norm == "spatial": + hidden_states = self.norm2(hidden_states, temb) + else: + hidden_states = self.norm2(hidden_states) + + if temb is not None and self.time_embedding_norm == "scale_shift": + scale, shift = torch.chunk(temb, 2, dim=1) + hidden_states = hidden_states * (1 + scale) + shift + + hidden_states = self.nonlinearity(hidden_states) + + hidden_states = self.dropout(hidden_states) + hidden_states = self.conv2(hidden_states) + + if self.conv_shortcut is not None: + input_tensor = self.conv_shortcut(input_tensor) + + output_tensor = (input_tensor + hidden_states) / self.output_scale_factor + + return output_tensor + + +def get_down_block3d( + down_block_type: str, + num_layers: int, + in_channels: int, + out_channels: int, + temb_channels: int, + add_downsample: bool, + downsample_stride: int, + resnet_eps: float, + resnet_act_fn: str, + transformer_layers_per_block: int = 1, + num_attention_heads: Optional[int] = None, + resnet_groups: Optional[int] = None, + cross_attention_dim: Optional[int] = None, + downsample_padding: Optional[int] = None, + dual_cross_attention: bool = False, + use_linear_projection: bool = False, + only_cross_attention: bool = False, + upcast_attention: bool = False, + resnet_time_scale_shift: str = "default", + attention_type: str = "default", + resnet_skip_time_act: bool = False, + resnet_out_scale_factor: float = 1.0, + cross_attention_norm: Optional[str] = None, + attention_head_dim: Optional[int] = None, + downsample_type: Optional[str] = None, + dropout: float = 0.0, +): + # If attn head dim is not defined, we default it to the number of heads + if attention_head_dim is None: + logger.warn( + f"It is recommended to provide `attention_head_dim` when calling `get_down_block`. Defaulting `attention_head_dim` to {num_attention_heads}." + ) + attention_head_dim = num_attention_heads + + down_block_type = down_block_type[7:] if down_block_type.startswith("UNetRes") else down_block_type + if down_block_type == "DownEncoderBlockCausal3D": + return DownEncoderBlockCausal3D( + num_layers=num_layers, + in_channels=in_channels, + out_channels=out_channels, + dropout=dropout, + add_downsample=add_downsample, + downsample_stride=downsample_stride, + resnet_eps=resnet_eps, + resnet_act_fn=resnet_act_fn, + resnet_groups=resnet_groups, + downsample_padding=downsample_padding, + resnet_time_scale_shift=resnet_time_scale_shift, + ) + raise ValueError(f"{down_block_type} does not exist.") + + +def get_up_block3d( + up_block_type: str, + num_layers: int, + in_channels: int, + out_channels: int, + prev_output_channel: int, + temb_channels: int, + add_upsample: bool, + upsample_scale_factor: Tuple, + resnet_eps: float, + resnet_act_fn: str, + resolution_idx: Optional[int] = None, + transformer_layers_per_block: int = 1, + num_attention_heads: Optional[int] = None, + resnet_groups: Optional[int] = None, + cross_attention_dim: Optional[int] = None, + dual_cross_attention: bool = False, + use_linear_projection: bool = False, + only_cross_attention: bool = False, + upcast_attention: bool = False, + resnet_time_scale_shift: str = "default", + attention_type: str = "default", + resnet_skip_time_act: bool = False, + resnet_out_scale_factor: float = 1.0, + cross_attention_norm: Optional[str] = None, + attention_head_dim: Optional[int] = None, + upsample_type: Optional[str] = None, + dropout: float = 0.0, +) -> nn.Module: + # If attn head dim is not defined, we default it to the number of heads + if attention_head_dim is None: + logger.warn( + f"It is recommended to provide `attention_head_dim` when calling `get_up_block`. Defaulting `attention_head_dim` to {num_attention_heads}." + ) + attention_head_dim = num_attention_heads + + up_block_type = up_block_type[7:] if up_block_type.startswith("UNetRes") else up_block_type + if up_block_type == "UpDecoderBlockCausal3D": + return UpDecoderBlockCausal3D( + num_layers=num_layers, + in_channels=in_channels, + out_channels=out_channels, + resolution_idx=resolution_idx, + dropout=dropout, + add_upsample=add_upsample, + upsample_scale_factor=upsample_scale_factor, + resnet_eps=resnet_eps, + resnet_act_fn=resnet_act_fn, + resnet_groups=resnet_groups, + resnet_time_scale_shift=resnet_time_scale_shift, + temb_channels=temb_channels, + ) + raise ValueError(f"{up_block_type} does not exist.") + + +class UNetMidBlockCausal3D(nn.Module): + """ + A 3D UNet mid-block [`UNetMidBlockCausal3D`] with multiple residual blocks and optional attention blocks. + """ + + def __init__( + self, + in_channels: int, + temb_channels: int, + dropout: float = 0.0, + num_layers: int = 1, + resnet_eps: float = 1e-6, + resnet_time_scale_shift: str = "default", # default, spatial + resnet_act_fn: str = "swish", + resnet_groups: int = 32, + attn_groups: Optional[int] = None, + resnet_pre_norm: bool = True, + add_attention: bool = True, + attention_head_dim: int = 1, + output_scale_factor: float = 1.0, + ): + super().__init__() + resnet_groups = resnet_groups if resnet_groups is not None else min(in_channels // 4, 32) + self.add_attention = add_attention + + if attn_groups is None: + attn_groups = resnet_groups if resnet_time_scale_shift == "default" else None + + # there is always at least one resnet + resnets = [ + ResnetBlockCausal3D( + in_channels=in_channels, + out_channels=in_channels, + temb_channels=temb_channels, + eps=resnet_eps, + groups=resnet_groups, + dropout=dropout, + time_embedding_norm=resnet_time_scale_shift, + non_linearity=resnet_act_fn, + output_scale_factor=output_scale_factor, + pre_norm=resnet_pre_norm, + ) + ] + attentions = [] + + if attention_head_dim is None: + logger.warn( + f"It is not recommend to pass `attention_head_dim=None`. Defaulting `attention_head_dim` to `in_channels`: {in_channels}." + ) + attention_head_dim = in_channels + + for _ in range(num_layers): + if self.add_attention: + attentions.append( + Attention( + in_channels, + heads=in_channels // attention_head_dim, + dim_head=attention_head_dim, + rescale_output_factor=output_scale_factor, + eps=resnet_eps, + norm_num_groups=attn_groups, + spatial_norm_dim=temb_channels if resnet_time_scale_shift == "spatial" else None, + residual_connection=True, + bias=True, + upcast_softmax=True, + _from_deprecated_attn_block=True, + ) + ) + else: + attentions.append(None) + + resnets.append( + ResnetBlockCausal3D( + in_channels=in_channels, + out_channels=in_channels, + temb_channels=temb_channels, + eps=resnet_eps, + groups=resnet_groups, + dropout=dropout, + time_embedding_norm=resnet_time_scale_shift, + non_linearity=resnet_act_fn, + output_scale_factor=output_scale_factor, + pre_norm=resnet_pre_norm, + ) + ) + + self.attentions = nn.ModuleList(attentions) + self.resnets = nn.ModuleList(resnets) + + def forward(self, hidden_states: torch.FloatTensor, temb: Optional[torch.FloatTensor] = None) -> torch.FloatTensor: + hidden_states = self.resnets[0](hidden_states, temb) + for attn, resnet in zip(self.attentions, self.resnets[1:]): + if attn is not None: + B, C, T, H, W = hidden_states.shape + hidden_states = rearrange(hidden_states, "b c f h w -> b (f h w) c") + attention_mask = prepare_causal_attention_mask(T, H * W, hidden_states.dtype, hidden_states.device, batch_size=B) + hidden_states = attn(hidden_states, temb=temb, attention_mask=attention_mask) + hidden_states = rearrange(hidden_states, "b (f h w) c -> b c f h w", f=T, h=H, w=W) + hidden_states = resnet(hidden_states, temb) + + return hidden_states + + +class DownEncoderBlockCausal3D(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + dropout: float = 0.0, + num_layers: int = 1, + resnet_eps: float = 1e-6, + resnet_time_scale_shift: str = "default", + resnet_act_fn: str = "swish", + resnet_groups: int = 32, + resnet_pre_norm: bool = True, + output_scale_factor: float = 1.0, + add_downsample: bool = True, + downsample_stride: int = 2, + downsample_padding: int = 1, + ): + super().__init__() + resnets = [] + + for i in range(num_layers): + in_channels = in_channels if i == 0 else out_channels + resnets.append( + ResnetBlockCausal3D( + in_channels=in_channels, + out_channels=out_channels, + temb_channels=None, + eps=resnet_eps, + groups=resnet_groups, + dropout=dropout, + time_embedding_norm=resnet_time_scale_shift, + non_linearity=resnet_act_fn, + output_scale_factor=output_scale_factor, + pre_norm=resnet_pre_norm, + ) + ) + + self.resnets = nn.ModuleList(resnets) + + if add_downsample: + self.downsamplers = nn.ModuleList( + [ + DownsampleCausal3D( + out_channels, + use_conv=True, + out_channels=out_channels, + padding=downsample_padding, + name="op", + stride=downsample_stride, + ) + ] + ) + else: + self.downsamplers = None + + def forward(self, hidden_states: torch.FloatTensor, scale: float = 1.0) -> torch.FloatTensor: + for resnet in self.resnets: + hidden_states = resnet(hidden_states, temb=None, scale=scale) + + if self.downsamplers is not None: + for downsampler in self.downsamplers: + hidden_states = downsampler(hidden_states, scale) + + return hidden_states + + +class UpDecoderBlockCausal3D(nn.Module): + def __init__( + self, + in_channels: int, + out_channels: int, + resolution_idx: Optional[int] = None, + dropout: float = 0.0, + num_layers: int = 1, + resnet_eps: float = 1e-6, + resnet_time_scale_shift: str = "default", # default, spatial + resnet_act_fn: str = "swish", + resnet_groups: int = 32, + resnet_pre_norm: bool = True, + output_scale_factor: float = 1.0, + add_upsample: bool = True, + upsample_scale_factor=(2, 2, 2), + temb_channels: Optional[int] = None, + ): + super().__init__() + resnets = [] + + for i in range(num_layers): + input_channels = in_channels if i == 0 else out_channels + + resnets.append( + ResnetBlockCausal3D( + in_channels=input_channels, + out_channels=out_channels, + temb_channels=temb_channels, + eps=resnet_eps, + groups=resnet_groups, + dropout=dropout, + time_embedding_norm=resnet_time_scale_shift, + non_linearity=resnet_act_fn, + output_scale_factor=output_scale_factor, + pre_norm=resnet_pre_norm, + ) + ) + + self.resnets = nn.ModuleList(resnets) + + if add_upsample: + self.upsamplers = nn.ModuleList( + [ + UpsampleCausal3D( + out_channels, + use_conv=True, + out_channels=out_channels, + upsample_factor=upsample_scale_factor, + ) + ] + ) + else: + self.upsamplers = None + + self.resolution_idx = resolution_idx + + def forward( + self, hidden_states: torch.FloatTensor, temb: Optional[torch.FloatTensor] = None, scale: float = 1.0 + ) -> torch.FloatTensor: + for resnet in self.resnets: + hidden_states = resnet(hidden_states, temb=temb, scale=scale) + + if self.upsamplers is not None: + for upsampler in self.upsamplers: + hidden_states = upsampler(hidden_states) + + return hidden_states diff --git a/src/musubi_tuner/modules/w8a8_optimization_utils.py b/src/musubi_tuner/modules/w8a8_optimization_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..908d73b61137051158caf5791d828ee1a3243e7b --- /dev/null +++ b/src/musubi_tuner/modules/w8a8_optimization_utils.py @@ -0,0 +1,256 @@ +""" +W8A8 activation quantization for reducing VRAM during LoRA training. + +Uses custom autograd.Functions that save only references to quantized weight +buffers instead of full-size dequantized weights, eliminating ~32MB per linear +layer from the autograd graph. + +Two modes: + - int8 (default): Converts FP8 weights to int8 per-channel, uses torch._int_mm. + Requires SM 7.5+ (Turing: RTX 2080+, T4, A100, etc.) + - fp8: Keeps FP8 weights as-is, uses transient dequantization. + Works on any GPU that supports FP8 (same as --fp8_scaled). +""" + +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F + +logger = logging.getLogger(__name__) + +SMALL_BATCH_THRESHOLD = 16 + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _dequantize_weight(weight, scale_weight): + """Dequantize quantized weight to float32, handling all scale shapes.""" + if scale_weight.ndim < 3: + # per-tensor [1] or per-channel [out, 1] + return weight.float() * scale_weight.float() + else: + # block-wise [out, num_blocks, 1] + out_features, num_blocks, _ = scale_weight.shape + w = weight.float().contiguous().view(out_features, num_blocks, -1) + w = w * scale_weight.float() + return w.view(weight.shape) + + +def _quantize_int8_per_token(x): + """Per-token int8 quantization. + + Args: + x: float tensor [M, K] + Returns: + (int8 tensor [M, K], float32 scale [M, 1]) + """ + abs_max = x.abs().amax(dim=-1, keepdim=True) + scale = (abs_max / 127.0).clamp(min=1e-30).float() + quantized = (x.float() / scale).round().clamp(-127, 127).to(torch.int8) + return quantized, scale + + +# --------------------------------------------------------------------------- +# Custom autograd Functions +# --------------------------------------------------------------------------- + +class _W8A8Int8Function(torch.autograd.Function): + """int8 W8A8: per-token input quantization + torch._int_mm. + + Saves only int8 weight and float32 per-channel scale in the autograd graph + (both are existing module buffers, so 0 extra bytes). + """ + + @staticmethod + def forward(ctx, x, weight_int8, weight_scale, bias): + # weight_int8: [out, in] int8 + # weight_scale: [out, 1] float32 + original_shape = x.shape + x_2d = x.reshape(-1, x.shape[-1]) + + x_int8, x_scale = _quantize_int8_per_token(x_2d) + + # [M, K] @ [K, N] -> [M, N] int32 (N = out_features) + # _int_mm handles transposed second operand (column-major) natively via cuBLAS; + # no .contiguous() needed on weight_int8.t(), which avoids a 16MB transient copy. + out_int32 = torch._int_mm(x_int8.contiguous(), weight_int8.t()) + + # Rescale: x_scale [M,1] * weight_scale^T [1,out] broadcasts to [M, out] + output = out_int32.float() * x_scale * weight_scale.t() + + if bias is not None: + output = output + bias.float() + + output = output.to(x.dtype).reshape(*original_shape[:-1], -1) + + # Save ONLY references to existing module buffers — 0 extra bytes + ctx.save_for_backward(weight_int8, weight_scale) + ctx.input_dtype = x.dtype + return output + + @staticmethod + def backward(ctx, grad_output): + # Only activation gradients are expected (LoRA-only training). + # needs_input_grad = (x=True, weight=False, scale=False, bias=False) + if ctx.needs_input_grad[1]: + raise RuntimeError( + "W8A8 int8 does not support weight gradients (full fine-tuning). " + "Use --network_module for LoRA training." + ) + + weight_int8, weight_scale = ctx.saved_tensors + # Transient dequantization — freed after this function returns + weight_f = weight_int8.float() * weight_scale # [out, in] + + go_2d = grad_output.reshape(-1, grad_output.shape[-1]).float() + grad_input = go_2d @ weight_f # [M, out] @ [out, in] -> [M, in] + grad_input = grad_input.to(ctx.input_dtype).reshape( + *grad_output.shape[:-1], weight_f.shape[1] + ) + return grad_input, None, None, None + + +class _W8A8TransientDequantFunction(torch.autograd.Function): + """Generic W8A8: dequantize transiently, don't save dequantized weight. + + Works with any quantized format (int8 per-channel, FP8 per-tensor/channel/block). + Uses standard F.linear for the forward matmul. + """ + + @staticmethod + def forward(ctx, x, weight, scale_weight, bias): + weight_deq = _dequantize_weight(weight, scale_weight).to(x.dtype) + output = F.linear(x, weight_deq, bias) + # weight_deq is NOT saved — freed when this scope ends + ctx.save_for_backward(weight, scale_weight) + ctx.input_dtype = x.dtype + return output + + @staticmethod + def backward(ctx, grad_output): + if ctx.needs_input_grad[1]: + raise RuntimeError( + "W8A8 does not support weight gradients (full fine-tuning). " + "Use --network_module for LoRA training." + ) + + weight, scale_weight = ctx.saved_tensors + weight_deq = _dequantize_weight(weight, scale_weight) # transient + + go_2d = grad_output.reshape(-1, grad_output.shape[-1]).float() + grad_input = go_2d @ weight_deq # [M, out] @ [out, in] + grad_input = grad_input.to(ctx.input_dtype).reshape( + *grad_output.shape[:-1], weight_deq.shape[1] + ) + return grad_input, None, None, None + + +# --------------------------------------------------------------------------- +# Weight conversion +# --------------------------------------------------------------------------- + +def _convert_fp8_to_int8_weights(module): + """One-time conversion: FP8 weight + scale -> int8 weight + per-channel scale. + + After conversion: + module.weight.data = int8 [out, in] + module.scale_weight = float32 [out, 1] + """ + with torch.no_grad(): + weight_float = _dequantize_weight(module.weight.data, module.scale_weight) + abs_max = weight_float.abs().amax(dim=1, keepdim=True) # [out, 1] + scale = (abs_max / 127.0).clamp(min=1e-30).float() + weight_int8 = (weight_float / scale).round().clamp(-127, 127).to(torch.int8) + + module.weight.requires_grad_(False) + module.weight.data = weight_int8 + module.scale_weight.data = scale # [out, 1] float32 + + +# --------------------------------------------------------------------------- +# Monkey-patched forward functions +# --------------------------------------------------------------------------- + +def _make_w8a8_int8_forward(use_int_mm): + """Create W8A8 int8 forward with small-batch fallback.""" + if use_int_mm: + def forward(self, x): + num_tokens = x.reshape(-1, x.shape[-1]).shape[0] + if num_tokens <= SMALL_BATCH_THRESHOLD: + w = (self.weight.detach().float() * self.scale_weight.float()).to(x.dtype) + return F.linear(x, w, self.bias) + return _W8A8Int8Function.apply(x, self.weight, self.scale_weight, self.bias) + else: + # _int_mm unavailable: still save VRAM via custom autograd + def forward(self, x): + num_tokens = x.reshape(-1, x.shape[-1]).shape[0] + if num_tokens <= SMALL_BATCH_THRESHOLD: + w = (self.weight.detach().float() * self.scale_weight.float()).to(x.dtype) + return F.linear(x, w, self.bias) + return _W8A8TransientDequantFunction.apply( + x, self.weight, self.scale_weight, self.bias + ) + return forward + + +def _make_w8a8_fp8_forward(): + """Create W8A8 fp8 forward with small-batch fallback.""" + def forward(self, x): + num_tokens = x.reshape(-1, x.shape[-1]).shape[0] + if num_tokens <= SMALL_BATCH_THRESHOLD: + w = _dequantize_weight(self.weight.detach(), self.scale_weight).to(x.dtype) + return F.linear(x, w, self.bias) + return _W8A8TransientDequantFunction.apply( + x, self.weight, self.scale_weight, self.bias + ) + return forward + + +# --------------------------------------------------------------------------- +# Public API +# --------------------------------------------------------------------------- + +def apply_w8a8_monkey_patch(model, w8a8_mode="int8"): + """Replace forward methods on FP8-patched linears with W8A8 versions. + + Must be called AFTER apply_fp8_monkey_patch + load_state_dict + (needs scale_weight buffers and loaded FP8 weights). + + For int8 mode: also converts FP8 weights to int8 per-channel. + + Args: + model: nn.Module with FP8-patched linear layers + w8a8_mode: "int8" (default, SM 7.5+) or "fp8" (any GPU) + """ + use_int_mm = hasattr(torch, "_int_mm") + if w8a8_mode == "int8" and not use_int_mm: + logger.warning( + "torch._int_mm not available (requires PyTorch 2.1+); " + "W8A8 int8 will use dequantize+matmul fallback (still saves VRAM)." + ) + + # Build the forward function once (shared by all patched layers) + if w8a8_mode == "int8": + new_forward = _make_w8a8_int8_forward(use_int_mm) + else: + new_forward = _make_w8a8_fp8_forward() + + patched_count = 0 + for name, module in model.named_modules(): + if not isinstance(module, nn.Linear): + continue + if not hasattr(module, "scale_weight"): + continue + + if w8a8_mode == "int8": + _convert_fp8_to_int8_weights(module) + + module.forward = new_forward.__get__(module, type(module)) + patched_count += 1 + + logger.info("W8A8 %s: patched %d linear layers", w8a8_mode, patched_count) + return model diff --git a/src/musubi_tuner/networks/__init__.py b/src/musubi_tuner/networks/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/musubi_tuner/networks/convert_hunyuan_video_1_5_lora_to_comfy.py b/src/musubi_tuner/networks/convert_hunyuan_video_1_5_lora_to_comfy.py new file mode 100644 index 0000000000000000000000000000000000000000..12fbc86d8168eaa1e7f6a55fa1deed9c6972abeb --- /dev/null +++ b/src/musubi_tuner/networks/convert_hunyuan_video_1_5_lora_to_comfy.py @@ -0,0 +1,166 @@ +import argparse +from safetensors.torch import save_file +from safetensors import safe_open + +import logging + +import torch + +from musubi_tuner.utils.model_utils import precalculate_safetensors_hashes + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +def main(args): + # load source safetensors + logger.info(f"Loading source file {args.src_path}") + state_dict = {} + with safe_open(args.src_path, framework="pt") as f: + metadata = f.metadata() + for key in f.keys(): + state_dict[key] = f.get_tensor(key) + + logger.info("Converting...") + + # Key mapping tables: (sd-scripts format, ComfyUI format) + double_blocks_mappings = [ + ("img_mlp_fc1", "img_mlp_0"), + ("img_mlp_fc2", "img_mlp_2"), + ("img_mod_linear", "img_mod_lin"), + ("txt_mlp_fc1", "txt_mlp_0"), + ("txt_mlp_fc2", "txt_mlp_2"), + ("txt_mod_linear", "txt_mod_lin"), + ] + + keys = list(state_dict.keys()) + count = 0 + + for key in keys: + new_k = key + + if "double_blocks" in key: + mappings = double_blocks_mappings + else: + continue + + # Apply mappings based on conversion direction + for src_key, dst_key in mappings: + if args.reverse: + # ComfyUI to sd-scripts: swap src and dst + new_k = new_k.replace(dst_key, src_key) + else: + # sd-scripts to ComfyUI: use as-is + new_k = new_k.replace(src_key, dst_key) + + if new_k != key: + state_dict[new_k] = state_dict.pop(key) + count += 1 + # print(f"Renamed {k} to {new_k}") + + # concat or split LoRA for QKV layers + qkv_count = 0 + if args.reverse: + # ComfyUI to sd-scripts: split QKV + keys = list(state_dict.keys()) + for key in keys: + if ("img_attn" in key or "txt_attn" in key) and "_qkv" in key and "lora_down" in key: + # get LoRA base name. e.g., "lora_unet_blocks_0_attn1_to_qkv.lora_down.weight" -> "lora_unet_blocks_0_attn1_to_qkv" + lora_name = key.split(".", 1)[0] + down_weight = state_dict.pop(f"{lora_name}.lora_down.weight") + up_weight = state_dict.pop(f"{lora_name}.lora_up.weight") + alpha = state_dict.pop(f"{lora_name}.alpha") + split_dims = [down_weight.size(0) // 3] * 3 # assume equal split for Q, K, V + + lora_name_prefix = lora_name.replace("_qkv", "") + + # dense weight (rank*3, in_dim) + split_weights = torch.chunk(down_weight, len(split_dims), dim=0) + for i, split_w in enumerate(split_weights): + suffix = ["_q", "_k", "_v"][i] + state_dict[f"{lora_name_prefix}{suffix}.lora_down.weight"] = split_w + state_dict[f"{lora_name_prefix}{suffix}.alpha"] = alpha / 3 # adjust alpha because rank is 3x larger + + # sparse weight (out_dim=sum(split_dims), rank*3) + split_dims = [up_weight.size(0) // 3] * 3 # assume equal split for Q, K, V + rank = up_weight.size(1) // len(split_dims) + weight_index = 0 + for i in range(len(split_dims)): + suffix = ["_q", "_k", "_v"][i] + split_up_weight = up_weight[weight_index : weight_index + split_dims[i], i * rank : (i + 1) * rank] + split_up_weight = split_up_weight.contiguous() # this solves an error in saving safetensors + state_dict[f"{lora_name_prefix}{suffix}.lora_up.weight"] = split_up_weight + state_dict[f"{lora_name_prefix}{suffix}.alpha"] = alpha / 3 # adjust alpha because rank is 3x larger + weight_index += split_dims[i] + + qkv_count += 1 + else: + # sd-scripts to ComfyUI: concat QKV + keys = list(state_dict.keys()) + for key in keys: + if ("img_attn" in key or "txt_attn" in key) and ("_q" in key or "_k" in key or "_v" in key): + if "_q" not in key or "lora_up" not in key: # ensure we process only once per QKV set + continue + + lora_name = key.split(".", 1)[0] # get LoRA base name + split_dims = [state_dict[key].size(0)] * 3 # assume equal split for Q, K, V + + lora_name_prefix = lora_name.replace("_q", "") + down_weights = [] # (rank, in_dim) * 3 + up_weights = [] # (split dim, rank) * 3 + for weight_index in range(len(split_dims)): + if weight_index == 0: + suffix = "_q" + elif weight_index == 1: + suffix = "_k" + else: + suffix = "_v" + down_weights.append(state_dict.pop(f"{lora_name_prefix}{suffix}.lora_down.weight")) + up_weights.append(state_dict.pop(f"{lora_name_prefix}{suffix}.lora_up.weight")) + + alpha = state_dict.pop(f"{lora_name}.alpha") + state_dict.pop(f"{lora_name_prefix}_k.alpha") + state_dict.pop(f"{lora_name_prefix}_v.alpha") + + # merge down weight + down_weight = torch.cat(down_weights, dim=0) # (rank, split_dim) * 3 -> (rank*3, sum of split_dim) + + # merge up weight (sum of split_dim, rank*3), dense to sparse + rank = up_weights[0].size(1) + up_weight = torch.zeros((sum(split_dims), down_weight.size(0)), device=down_weight.device, dtype=down_weight.dtype) + weight_index = 0 + for i in range(len(split_dims)): + up_weight[weight_index : weight_index + split_dims[i], i * rank : (i + 1) * rank] = up_weights[i] + weight_index += split_dims[i] + + new_lora_name = lora_name_prefix + "_qkv" + state_dict[f"{new_lora_name}.lora_down.weight"] = down_weight + state_dict[f"{new_lora_name}.lora_up.weight"] = up_weight + + # adjust alpha because rank is 3x larger. See https://github.com/kohya-ss/sd-scripts/issues/2204 + state_dict[f"{new_lora_name}.alpha"] = alpha * 3 + + qkv_count += 1 + + logger.info(f"Direct key renames applied: {count}") + logger.info(f"QKV LoRA layers processed: {qkv_count}") + + # Calculate hash + if metadata is not None: + logger.info("Calculating hashes and creating metadata...") + model_hash, legacy_hash = precalculate_safetensors_hashes(state_dict, metadata) + metadata["sshs_model_hash"] = model_hash + metadata["sshs_legacy_hash"] = legacy_hash + + # save destination safetensors + logger.info(f"Saving destination file {args.dst_path}") + save_file(state_dict, args.dst_path, metadata=metadata) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Convert LoRA format") + parser.add_argument("src_path", type=str, default=None, help="source path, sd-scripts format") + parser.add_argument("dst_path", type=str, default=None, help="destination path, ComfyUI format") + parser.add_argument("--reverse", action="store_true", help="reverse conversion direction") + args = parser.parse_args() + main(args) diff --git a/src/musubi_tuner/networks/convert_z_image_lora_to_comfy.py b/src/musubi_tuner/networks/convert_z_image_lora_to_comfy.py new file mode 100644 index 0000000000000000000000000000000000000000..b93060a6aa84538064557ddcaabf864e9bdac8f8 --- /dev/null +++ b/src/musubi_tuner/networks/convert_z_image_lora_to_comfy.py @@ -0,0 +1,303 @@ +import argparse +from safetensors.torch import save_file +from safetensors import safe_open + +import logging + +import torch + +from musubi_tuner.utils.model_utils import precalculate_safetensors_hashes + +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + + +def main(args): + # load source safetensors + logger.info(f"Loading source file {args.src_path}") + state_dict = {} + with safe_open(args.src_path, framework="pt") as f: + metadata = f.metadata() + for key in f.keys(): + state_dict[key] = f.get_tensor(key) + + logger.info("Converting...") + + # Key mapping tables: (sd-scripts format, ComfyUI format) + blocks_mappings = [ + ("attention_to_out_0", "attention_out"), + ("attention_norm_k", "attention_k_norm"), + ("attention_norm_q", "attention_q_norm"), + ] + + keys = list(state_dict.keys()) + count = 0 + + for key in keys: + new_k = key + + if "layers" in key: + mappings = blocks_mappings + else: + continue + + # Apply mappings based on conversion direction + for src_key, dst_key in mappings: + if args.reverse: + # ComfyUI to sd-scripts: swap src and dst + new_k = new_k.replace(dst_key, src_key) + else: + # sd-scripts to ComfyUI: use as-is + new_k = new_k.replace(src_key, dst_key) + + if new_k != key: + state_dict[new_k] = state_dict.pop(key) + count += 1 + # print(f"Renamed {k} to {new_k}") + + # concat or split LoRA/LoHa/LoKr for QKV layers + qkv_count = 0 + if args.reverse: + # ComfyUI to sd-scripts: split QKV (LoRA only) + keys = list(state_dict.keys()) + for key in keys: + if "attention_qkv" in key and "lora_down" in key: + # get LoRA base name. e.g., "lora_unet_blocks_0_attn1_to_qkv.lora_down.weight" -> "lora_unet_blocks_0_attn1_to_qkv" + lora_name = key.split(".", 1)[0] + down_weight = state_dict.pop(f"{lora_name}.lora_down.weight") + up_weight = state_dict.pop(f"{lora_name}.lora_up.weight") + alpha = state_dict.pop(f"{lora_name}.alpha") + split_dims = [down_weight.size(0) // 3] * 3 # assume equal split for Q, K, V + + lora_name_prefix = lora_name.replace("qkv", "") + + # dense weight (rank*3, in_dim) + split_weights = torch.chunk(down_weight, len(split_dims), dim=0) + for i, split_w in enumerate(split_weights): + suffix = ["to_q", "to_k", "to_v"][i] + state_dict[f"{lora_name_prefix}{suffix}.lora_down.weight"] = split_w + state_dict[f"{lora_name_prefix}{suffix}.alpha"] = alpha / 3 # adjust alpha because rank is 3x larger + + # sparse weight (out_dim=sum(split_dims), rank*3) + split_dims = [up_weight.size(0) // 3] * 3 # assume equal split for Q, K, V + rank = up_weight.size(1) // len(split_dims) + weight_index = 0 + for i in range(len(split_dims)): + suffix = ["to_q", "to_k", "to_v"][i] + split_up_weight = up_weight[weight_index : weight_index + split_dims[i], i * rank : (i + 1) * rank] + split_up_weight = split_up_weight.contiguous() # this solves an error in saving safetensors + state_dict[f"{lora_name_prefix}{suffix}.lora_up.weight"] = split_up_weight + state_dict[f"{lora_name_prefix}{suffix}.alpha"] = alpha / 3 # adjust alpha because rank is 3x larger + weight_index += split_dims[i] + + qkv_count += 1 + else: + # sd-scripts to ComfyUI: concat QKV + + # LoRA QKV merge + keys = list(state_dict.keys()) + for key in keys: + if key not in state_dict: + continue + if "attention" in key and ("to_q" in key or "to_k" in key or "to_v" in key): + if "to_q" not in key or "lora_up" not in key: # ensure we process only once per QKV set + continue + + lora_name = key.split(".", 1)[0] # get LoRA base name + split_dims = [state_dict[key].size(0)] * 3 # assume equal split for Q, K, V + + lora_name_prefix = lora_name.replace("to_q", "") + down_weights = [] # (rank, in_dim) * 3 + up_weights = [] # (split dim, rank) * 3 + for weight_index in range(len(split_dims)): + if weight_index == 0: + suffix = "to_q" + elif weight_index == 1: + suffix = "to_k" + else: + suffix = "to_v" + down_weights.append(state_dict.pop(f"{lora_name_prefix}{suffix}.lora_down.weight")) + up_weights.append(state_dict.pop(f"{lora_name_prefix}{suffix}.lora_up.weight")) + + alpha = state_dict.pop(f"{lora_name}.alpha") + state_dict.pop(f"{lora_name_prefix}to_k.alpha") + state_dict.pop(f"{lora_name_prefix}to_v.alpha") + + # merge down weight + down_weight = torch.cat(down_weights, dim=0) # (rank, split_dim) * 3 -> (rank*3, sum of split_dim) + + # merge up weight (sum of split_dim, rank*3), dense to sparse + rank = up_weights[0].size(1) + up_weight = torch.zeros((sum(split_dims), down_weight.size(0)), device=down_weight.device, dtype=down_weight.dtype) + weight_index = 0 + for i in range(len(split_dims)): + up_weight[weight_index : weight_index + split_dims[i], i * rank : (i + 1) * rank] = up_weights[i] + weight_index += split_dims[i] + + new_lora_name = lora_name_prefix + "qkv" + state_dict[f"{new_lora_name}.lora_down.weight"] = down_weight + state_dict[f"{new_lora_name}.lora_up.weight"] = up_weight + + # adjust alpha because rank is 3x larger. See https://github.com/kohya-ss/sd-scripts/issues/2204 + state_dict[f"{new_lora_name}.alpha"] = alpha * 3 + + qkv_count += 1 + + # LoHa QKV merge (block-diagonal, lossless) + # ΔW = (w1a @ w1b) ⊙ (w2a @ w2b) * scale + # Using block_diag for w1a/w2a and cat for w1b/w2b preserves the exact result: + # block_diag(w1a_q, w1a_k, w1a_v) @ cat(w1b_q, w1b_k, w1b_v) + # = [w1a_q@w1b_q; w1a_k@w1b_k; w1a_v@w1b_v] + # Rank becomes 3x, alpha is adjusted accordingly. + keys = list(state_dict.keys()) + for key in keys: + if key not in state_dict: + continue + if "attention" in key and ("to_q" in key or "to_k" in key or "to_v" in key): + if "to_q" not in key or "hada_w1_a" not in key: + continue + + lora_name = key.split(".", 1)[0] + lora_name_prefix = lora_name.replace("to_q", "") + + w1a_list, w1b_list, w2a_list, w2b_list = [], [], [], [] + for suffix in ["to_q", "to_k", "to_v"]: + name = f"{lora_name_prefix}{suffix}" + w1a_list.append(state_dict.pop(f"{name}.hada_w1_a")) + w1b_list.append(state_dict.pop(f"{name}.hada_w1_b")) + w2a_list.append(state_dict.pop(f"{name}.hada_w2_a")) + w2b_list.append(state_dict.pop(f"{name}.hada_w2_b")) + + alpha = state_dict.pop(f"{lora_name}.alpha") + state_dict.pop(f"{lora_name_prefix}to_k.alpha", None) + state_dict.pop(f"{lora_name_prefix}to_v.alpha", None) + + w1a_qkv = torch.block_diag(*w1a_list) # (3*out, 3r) + w1b_qkv = torch.cat(w1b_list, dim=0) # (3r, in) + w2a_qkv = torch.block_diag(*w2a_list) # (3*out, 3r) + w2b_qkv = torch.cat(w2b_list, dim=0) # (3r, in) + + new_lora_name = lora_name_prefix + "qkv" + state_dict[f"{new_lora_name}.hada_w1_a"] = w1a_qkv + state_dict[f"{new_lora_name}.hada_w1_b"] = w1b_qkv + state_dict[f"{new_lora_name}.hada_w2_a"] = w2a_qkv + state_dict[f"{new_lora_name}.hada_w2_b"] = w2b_qkv + state_dict[f"{new_lora_name}.alpha"] = alpha * 3 # rank is 3x, so alpha * 3 keeps scale unchanged + + qkv_count += 1 + + # LoKr QKV merge: materialize weight deltas via Kronecker product, concatenate, convert to LoRA via SVD + # Kronecker product structure cannot be preserved across QKV concatenation, + # so we convert QKV layers to LoRA format. Non-QKV layers remain as LoKr. + keys = list(state_dict.keys()) + for key in keys: + if key not in state_dict: + continue + if "attention" in key and ("to_q" in key or "to_k" in key or "to_v" in key): + if "to_q" not in key or "lokr_w1" not in key: + continue + + lora_name = key.split(".", 1)[0] + lora_name_prefix = lora_name.replace("to_q", "") + + delta_weights = [] + original_dtype = None + for suffix in ["to_q", "to_k", "to_v"]: + name = f"{lora_name_prefix}{suffix}" + w1 = state_dict.pop(f"{name}.lokr_w1") + if original_dtype is None: + original_dtype = w1.dtype + + w2a_key = f"{name}.lokr_w2_a" + w2b_key = f"{name}.lokr_w2_b" + w2_key = f"{name}.lokr_w2" + + if w2a_key in state_dict: + # low-rank mode: w2 = w2_a @ w2_b + w2a = state_dict.pop(w2a_key) + w2b = state_dict.pop(w2b_key) + dim = w2a.shape[1] + w2 = w2a.float() @ w2b.float() + elif w2_key in state_dict: + # full matrix mode + w2 = state_dict.pop(w2_key).float() + dim = None + else: + raise ValueError(f"Missing lokr_w2 weights for {name}") + + alpha_i = state_dict.pop(f"{name}.alpha", None) + + # Compute scale: low-rank uses alpha/dim, full matrix uses 1.0 + if dim is not None: + if alpha_i is not None: + alpha_val = alpha_i.item() if isinstance(alpha_i, torch.Tensor) else alpha_i + else: + alpha_val = dim + scale = alpha_val / dim + else: + scale = 1.0 + + delta_w = torch.kron(w1.float(), w2) * scale + delta_weights.append(delta_w) + + # Concatenate QKV deltas + delta_qkv = torch.cat(delta_weights, dim=0) # (3*out, in) + + # SVD decomposition + U, S, Vt = torch.linalg.svd(delta_qkv, full_matrices=False) + + # Determine rank + if args.lokr_rank is not None: + svd_rank = min(args.lokr_rank, S.shape[0]) + else: + # Auto: keep singular values contributing to 99.99% of total energy (Frobenius norm squared) + total_energy = (S**2).sum() + cumulative_energy = (S**2).cumsum(dim=0) + threshold_idx = (cumulative_energy >= total_energy * 0.9999).nonzero(as_tuple=True)[0] + if len(threshold_idx) > 0: + svd_rank = threshold_idx[0].item() + 1 + else: + svd_rank = S.shape[0] + + # Log reconstruction quality + reconstructed = (U[:, :svd_rank] * S[:svd_rank].unsqueeze(0)) @ Vt[:svd_rank, :] + rel_error = (delta_qkv - reconstructed).norm() / delta_qkv.norm() + logger.info(f" LoKr->LoRA QKV {lora_name_prefix}qkv: rank={svd_rank}/{S.shape[0]}, relative error={rel_error:.6f}") + + # Construct LoRA weights: ΔW ≈ lora_up @ lora_down, with alpha = rank (scale = 1) + sqrt_S = torch.sqrt(S[:svd_rank]) + lora_up = (U[:, :svd_rank] * sqrt_S.unsqueeze(0)).to(original_dtype) # (3*out, rank) + lora_down = (sqrt_S.unsqueeze(1) * Vt[:svd_rank, :]).to(original_dtype) # (rank, in) + + new_lora_name = lora_name_prefix + "qkv" + state_dict[f"{new_lora_name}.lora_up.weight"] = lora_up + state_dict[f"{new_lora_name}.lora_down.weight"] = lora_down + state_dict[f"{new_lora_name}.alpha"] = torch.tensor(float(svd_rank)) + + qkv_count += 1 + + logger.info(f"Direct key renames applied: {count}") + logger.info(f"QKV layers processed: {qkv_count}") + + # Calculate hash + if metadata is not None: + logger.info("Calculating hashes and creating metadata...") + model_hash, legacy_hash = precalculate_safetensors_hashes(state_dict, metadata) + metadata["sshs_model_hash"] = model_hash + metadata["sshs_legacy_hash"] = legacy_hash + + # save destination safetensors + logger.info(f"Saving destination file {args.dst_path}") + save_file(state_dict, args.dst_path, metadata=metadata) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Convert LoRA/LoHa/LoKr format for Z-Image ComfyUI") + parser.add_argument("src_path", type=str, default=None, help="source path, sd-scripts format") + parser.add_argument("dst_path", type=str, default=None, help="destination path, ComfyUI format") + parser.add_argument("--reverse", action="store_true", help="reverse conversion direction (LoRA only)") + parser.add_argument( + "--lokr_rank", type=int, default=None, help="max rank for LoKr to LoRA QKV conversion (auto if not specified)" + ) + args = parser.parse_args() + main(args) diff --git a/src/musubi_tuner/networks/loha.py b/src/musubi_tuner/networks/loha.py new file mode 100644 index 0000000000000000000000000000000000000000..f736e0fb96349449d7843db5930b0c414039cff6 --- /dev/null +++ b/src/musubi_tuner/networks/loha.py @@ -0,0 +1,345 @@ +# LoHa (Low-rank Hadamard Product) network module +# Linear layers only (no Conv2d/Tucker decomposition) +# Reference: https://arxiv.org/abs/2108.06098 +# +# Based on the LyCORIS project by KohakuBlueleaf +# https://github.com/KohakuBlueleaf/LyCORIS + +import ast +import logging +from typing import Dict, List, Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from . import lora as lora_module +from .network_arch import detect_arch_config + +logger = logging.getLogger(__name__) + + +class HadaWeight(torch.autograd.Function): + """Efficient Hadamard product forward/backward for LoHa. + + Computes ((w1a @ w1b) * (w2a @ w2b)) * scale with custom backward + that recomputes intermediates instead of storing them. + """ + + @staticmethod + def forward(ctx, w1a, w1b, w2a, w2b, scale=None): + if scale is None: + scale = torch.tensor(1, device=w1a.device, dtype=w1a.dtype) + ctx.save_for_backward(w1a, w1b, w2a, w2b, scale) + diff_weight = ((w1a @ w1b) * (w2a @ w2b)) * scale + return diff_weight + + @staticmethod + def backward(ctx, grad_out): + (w1a, w1b, w2a, w2b, scale) = ctx.saved_tensors + grad_out = grad_out * scale + temp = grad_out * (w2a @ w2b) + grad_w1a = temp @ w1b.T + grad_w1b = w1a.T @ temp + + temp = grad_out * (w1a @ w1b) + grad_w2a = temp @ w2b.T + grad_w2b = w2a.T @ temp + + del temp + return grad_w1a, grad_w1b, grad_w2a, grad_w2b, None + + +class LoHaModule(torch.nn.Module): + """LoHa module for training. Replaces forward method of the original Linear.""" + + def __init__( + self, + lora_name, + org_module: torch.nn.Module, + multiplier=1.0, + lora_dim=4, + alpha=1, + dropout=None, + rank_dropout=None, + module_dropout=None, + **kwargs, + ): + super().__init__() + self.lora_name = lora_name + self.lora_dim = lora_dim + + if org_module.__class__.__name__ == "Conv2d": + raise ValueError("LoHa Conv2d is not supported in this implementation") + else: + in_dim = org_module.in_features + out_dim = org_module.out_features + + # Hadamard product parameters: ΔW = (w1a @ w1b) * (w2a @ w2b) + self.hada_w1_a = nn.Parameter(torch.empty(out_dim, lora_dim)) + self.hada_w1_b = nn.Parameter(torch.empty(lora_dim, in_dim)) + self.hada_w2_a = nn.Parameter(torch.empty(out_dim, lora_dim)) + self.hada_w2_b = nn.Parameter(torch.empty(lora_dim, in_dim)) + + # Initialization: w1_a normal(0.1), w1_b normal(1.0), w2_a = 0, w2_b normal(1.0) + # Ensures ΔW = 0 at init since w2_a = 0 + torch.nn.init.normal_(self.hada_w1_a, std=0.1) + torch.nn.init.normal_(self.hada_w1_b, std=1.0) + torch.nn.init.constant_(self.hada_w2_a, 0) + torch.nn.init.normal_(self.hada_w2_b, std=1.0) + + if type(alpha) == torch.Tensor: + alpha = alpha.detach().float().numpy() + alpha = lora_dim if alpha is None or alpha == 0 else alpha + self.scale = alpha / self.lora_dim + self.register_buffer("alpha", torch.tensor(alpha)) + + self.multiplier = multiplier + self.org_module = org_module # remove in applying + self.dropout = dropout + self.rank_dropout = rank_dropout + self.module_dropout = module_dropout + + def apply_to(self): + self.org_forward = self.org_module.forward + self.org_module.forward = self.forward + del self.org_module + + def get_diff_weight(self): + """Return materialized weight delta.""" + scale = torch.tensor(self.scale, dtype=self.hada_w1_a.dtype, device=self.hada_w1_a.device) + return HadaWeight.apply(self.hada_w1_a, self.hada_w1_b, self.hada_w2_a, self.hada_w2_b, scale) + + def forward(self, x): + org_forwarded = self.org_forward(x) + + # module dropout + if self.module_dropout is not None and self.training: + if torch.rand(1) < self.module_dropout: + return org_forwarded + + diff_weight = self.get_diff_weight() + + # rank dropout + if self.rank_dropout is not None and self.training: + drop = (torch.rand(diff_weight.size(0), device=diff_weight.device) > self.rank_dropout).to(diff_weight.dtype) + drop = drop.view(-1, 1) + diff_weight = diff_weight * drop + # scaling for rank dropout + scale = 1.0 / (1.0 - self.rank_dropout) + else: + scale = 1.0 + + return org_forwarded + F.linear(x, diff_weight) * self.multiplier * scale + + +class LoHaInfModule(LoHaModule): + """LoHa module for inference. Supports merge_to and get_weight.""" + + def __init__( + self, + lora_name, + org_module: torch.nn.Module, + multiplier=1.0, + lora_dim=4, + alpha=1, + **kwargs, + ): + # no dropout for inference + super().__init__(lora_name, org_module, multiplier, lora_dim, alpha) + + self.org_module_ref = [org_module] + self.enabled = True + self.network: lora_module.LoRANetwork = None + + def set_network(self, network): + self.network = network + + def merge_to(self, sd, dtype, device, non_blocking=False): + # extract weight from org_module + org_sd = self.org_module.state_dict() + weight = org_sd["weight"] + org_dtype = weight.dtype + org_device = weight.device + weight = weight.to(device, dtype=torch.float, non_blocking=non_blocking) + + if dtype is None: + dtype = org_dtype + if device is None: + device = org_device + + # get LoHa weights + w1a = sd["hada_w1_a"].to(device, dtype=torch.float, non_blocking=non_blocking) + w1b = sd["hada_w1_b"].to(device, dtype=torch.float, non_blocking=non_blocking) + w2a = sd["hada_w2_a"].to(device, dtype=torch.float, non_blocking=non_blocking) + w2b = sd["hada_w2_b"].to(device, dtype=torch.float, non_blocking=non_blocking) + + # compute ΔW = ((w1a @ w1b) * (w2a @ w2b)) * scale + diff_weight = ((w1a @ w1b) * (w2a @ w2b)) * self.scale + + # merge + weight = weight + self.multiplier * diff_weight + + org_sd["weight"] = weight.to(org_device, dtype=dtype) + self.org_module.load_state_dict(org_sd) + + def get_weight(self, multiplier=None): + if multiplier is None: + multiplier = self.multiplier + + w1a = self.hada_w1_a.to(torch.float) + w1b = self.hada_w1_b.to(torch.float) + w2a = self.hada_w2_a.to(torch.float) + w2b = self.hada_w2_b.to(torch.float) + + weight = ((w1a @ w1b) * (w2a @ w2b)) * self.scale * multiplier + return weight + + def default_forward(self, x): + diff_weight = self.get_diff_weight() + return self.org_forward(x) + F.linear(x, diff_weight) * self.multiplier + + def forward(self, x): + if not self.enabled: + return self.org_forward(x) + return self.default_forward(x) + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + """Create a LoHa network with auto-detected architecture.""" + target_replace_modules, default_excludes = detect_arch_config(unet) + + # merge user exclude_patterns with defaults + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + exclude_patterns.extend(default_excludes) + kwargs["exclude_patterns"] = exclude_patterns + + return lora_module.create_network( + target_replace_modules, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + module_class=LoHaModule, + **kwargs, + ) + + +def create_network_from_weights( + target_replace_modules: List[str], + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora_module.LoRANetwork: + """Create LoHa network from saved weights (internal).""" + modules_dim = {} + modules_alpha = {} + for key, value in weights_sd.items(): + if "." not in key: + continue + + lora_name = key.split(".")[0] + if "alpha" in key: + modules_alpha[lora_name] = value + elif "hada_w1_b" in key: + dim = value.shape[0] + modules_dim[lora_name] = dim + + module_class = LoHaInfModule if for_inference else LoHaModule + + network = lora_module.LoRANetwork( + target_replace_modules, + "lora_unet", + text_encoders, + unet, + multiplier=multiplier, + modules_dim=modules_dim, + modules_alpha=modules_alpha, + module_class=module_class, + ) + return network + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora_module.LoRANetwork: + """Create LoHa network from saved weights with auto-detected architecture.""" + target_replace_modules, _ = detect_arch_config(unet) + return create_network_from_weights(target_replace_modules, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs) + + +def merge_weights_to_tensor( + model_weight: torch.Tensor, + lora_name: str, + lora_sd: Dict[str, torch.Tensor], + lora_weight_keys: set, + multiplier: float, + calc_device: torch.device, +) -> torch.Tensor: + """Merge LoHa weights directly into a model weight tensor. + + No Module/Network creation needed. Consumed keys are removed from lora_weight_keys. + Returns model_weight unchanged if no matching LoHa keys found. + """ + w1a_key = lora_name + ".hada_w1_a" + w1b_key = lora_name + ".hada_w1_b" + w2a_key = lora_name + ".hada_w2_a" + w2b_key = lora_name + ".hada_w2_b" + alpha_key = lora_name + ".alpha" + + if w1a_key not in lora_weight_keys: + return model_weight + + w1a = lora_sd[w1a_key].to(calc_device) + w1b = lora_sd[w1b_key].to(calc_device) + w2a = lora_sd[w2a_key].to(calc_device) + w2b = lora_sd[w2b_key].to(calc_device) + + dim = w1b.shape[0] + alpha = lora_sd.get(alpha_key, torch.tensor(dim)) + if isinstance(alpha, torch.Tensor): + alpha = alpha.item() + scale = alpha / dim + + original_dtype = model_weight.dtype + if original_dtype.itemsize == 1: # fp8 + model_weight = model_weight.to(torch.float16) + w1a, w1b, w2a, w2b = w1a.to(torch.float16), w1b.to(torch.float16), w2a.to(torch.float16), w2b.to(torch.float16) + + # ΔW = ((w1a @ w1b) * (w2a @ w2b)) * scale + diff_weight = ((w1a @ w1b) * (w2a @ w2b)) * scale + model_weight = model_weight + multiplier * diff_weight + + if original_dtype.itemsize == 1: + model_weight = model_weight.to(original_dtype) + + # remove consumed keys + for key in [w1a_key, w1b_key, w2a_key, w2b_key, alpha_key]: + lora_weight_keys.discard(key) + + return model_weight diff --git a/src/musubi_tuner/networks/lokr.py b/src/musubi_tuner/networks/lokr.py new file mode 100644 index 0000000000000000000000000000000000000000..2c8b641038f6d0a373337421fee1e7040ff1184e --- /dev/null +++ b/src/musubi_tuner/networks/lokr.py @@ -0,0 +1,440 @@ +# LoKr (Low-rank Kronecker Product) network module +# Linear layers only (no Conv2d/Tucker decomposition) +# Reference: https://arxiv.org/abs/2309.14859 +# +# Based on the LyCORIS project by KohakuBlueleaf +# https://github.com/KohakuBlueleaf/LyCORIS + +import ast +import logging +import math +from typing import Dict, List, Optional + +import torch +import torch.nn as nn +import torch.nn.functional as F + +from . import lora as lora_module +from .network_arch import detect_arch_config + +logger = logging.getLogger(__name__) + + +def factorization(dimension: int, factor: int = -1) -> tuple: + """Return a tuple of two values whose product equals dimension, + optimized for balanced factors. + + In LoKr, the first value is for the weight scale (smaller), + and the second value is for the weight (larger). + + Examples: + factor=-1: 128 -> (8, 16), 512 -> (16, 32), 1024 -> (32, 32) + factor=4: 128 -> (4, 32), 512 -> (4, 128) + """ + if factor > 0 and (dimension % factor) == 0: + m = factor + n = dimension // factor + if m > n: + n, m = m, n + return m, n + if factor < 0: + factor = dimension + m, n = 1, dimension + length = m + n + while m < n: + new_m = m + 1 + while dimension % new_m != 0: + new_m += 1 + new_n = dimension // new_m + if new_m + new_n > length or new_m > factor: + break + else: + m, n = new_m, new_n + if m > n: + n, m = m, n + return m, n + + +def make_kron(w1, w2, scale): + """Compute Kronecker product of w1 and w2, scaled by scale.""" + if w1.dim() != w2.dim(): + for _ in range(w2.dim() - w1.dim()): + w1 = w1.unsqueeze(-1) + w2 = w2.contiguous() + rebuild = torch.kron(w1, w2) + if scale != 1: + rebuild = rebuild * scale + return rebuild + + +class LoKrModule(torch.nn.Module): + """LoKr module for training. Replaces forward method of the original Linear.""" + + def __init__( + self, + lora_name, + org_module: torch.nn.Module, + multiplier=1.0, + lora_dim=4, + alpha=1, + dropout=None, + rank_dropout=None, + module_dropout=None, + factor=-1, + **kwargs, + ): + super().__init__() + self.lora_name = lora_name + self.lora_dim = lora_dim + + if org_module.__class__.__name__ == "Conv2d": + raise ValueError("LoKr Conv2d is not supported in this implementation") + else: + in_dim = org_module.in_features + out_dim = org_module.out_features + + factor = int(factor) + self.use_w2 = False + + # Factorize dimensions + in_m, in_n = factorization(in_dim, factor) + out_l, out_k = factorization(out_dim, factor) + + # w1 is always a full matrix (the "scale" factor, small) + self.lokr_w1 = nn.Parameter(torch.empty(out_l, in_m)) + + # w2: low-rank decomposition if rank is small enough, otherwise full matrix + if lora_dim < max(out_k, in_n) / 2: + self.lokr_w2_a = nn.Parameter(torch.empty(out_k, lora_dim)) + self.lokr_w2_b = nn.Parameter(torch.empty(lora_dim, in_n)) + else: + self.use_w2 = True + self.lokr_w2 = nn.Parameter(torch.empty(out_k, in_n)) + if lora_dim >= max(out_k, in_n) / 2: + logger.warning( + f"LoKr: lora_dim {lora_dim} is large for dim={max(in_dim, out_dim)} " + f"and factor={factor}, using full matrix mode." + ) + + if type(alpha) == torch.Tensor: + alpha = alpha.detach().float().numpy() + alpha = lora_dim if alpha is None or alpha == 0 else alpha + # if both w1 and w2 are full matrices, use scale = 1 + if self.use_w2: + alpha = lora_dim + self.scale = alpha / self.lora_dim + self.register_buffer("alpha", torch.tensor(alpha)) + + # Initialization + torch.nn.init.kaiming_uniform_(self.lokr_w1, a=math.sqrt(5)) + if self.use_w2: + torch.nn.init.constant_(self.lokr_w2, 0) + else: + torch.nn.init.kaiming_uniform_(self.lokr_w2_a, a=math.sqrt(5)) + torch.nn.init.constant_(self.lokr_w2_b, 0) + # Ensures ΔW = kron(w1, 0) = 0 at init + + self.multiplier = multiplier + self.org_module = org_module # remove in applying + self.dropout = dropout + self.rank_dropout = rank_dropout + self.module_dropout = module_dropout + + def apply_to(self): + self.org_forward = self.org_module.forward + self.org_module.forward = self.forward + del self.org_module + + def get_diff_weight(self): + """Return materialized weight delta.""" + w1 = self.lokr_w1 + if self.use_w2: + w2 = self.lokr_w2 + else: + w2 = self.lokr_w2_a @ self.lokr_w2_b + return make_kron(w1, w2, self.scale) + + def forward(self, x): + org_forwarded = self.org_forward(x) + + # module dropout + if self.module_dropout is not None and self.training: + if torch.rand(1) < self.module_dropout: + return org_forwarded + + diff_weight = self.get_diff_weight() + + # rank dropout + if self.rank_dropout is not None and self.training: + drop = (torch.rand(diff_weight.size(0), device=diff_weight.device) > self.rank_dropout).to(diff_weight.dtype) + drop = drop.view(-1, 1) + diff_weight = diff_weight * drop + scale = 1.0 / (1.0 - self.rank_dropout) + else: + scale = 1.0 + + return org_forwarded + F.linear(x, diff_weight) * self.multiplier * scale + + +class LoKrInfModule(LoKrModule): + """LoKr module for inference. Supports merge_to and get_weight.""" + + def __init__( + self, + lora_name, + org_module: torch.nn.Module, + multiplier=1.0, + lora_dim=4, + alpha=1, + **kwargs, + ): + # no dropout for inference; pass factor from kwargs if present + factor = kwargs.pop("factor", -1) + super().__init__(lora_name, org_module, multiplier, lora_dim, alpha, factor=factor) + + self.org_module_ref = [org_module] + self.enabled = True + self.network: lora_module.LoRANetwork = None + + def set_network(self, network): + self.network = network + + def merge_to(self, sd, dtype, device, non_blocking=False): + # extract weight from org_module + org_sd = self.org_module.state_dict() + weight = org_sd["weight"] + org_dtype = weight.dtype + org_device = weight.device + weight = weight.to(device, dtype=torch.float, non_blocking=non_blocking) + + if dtype is None: + dtype = org_dtype + if device is None: + device = org_device + + # get LoKr weights + w1 = sd["lokr_w1"].to(device, dtype=torch.float, non_blocking=non_blocking) + + if "lokr_w2" in sd: + w2 = sd["lokr_w2"].to(device, dtype=torch.float, non_blocking=non_blocking) + else: + w2a = sd["lokr_w2_a"].to(device, dtype=torch.float, non_blocking=non_blocking) + w2b = sd["lokr_w2_b"].to(device, dtype=torch.float, non_blocking=non_blocking) + w2 = w2a @ w2b + + # compute ΔW via Kronecker product + diff_weight = make_kron(w1, w2, self.scale) + + # merge + weight = weight + self.multiplier * diff_weight + + org_sd["weight"] = weight.to(org_device, dtype=dtype) + self.org_module.load_state_dict(org_sd) + + def get_weight(self, multiplier=None): + if multiplier is None: + multiplier = self.multiplier + + w1 = self.lokr_w1.to(torch.float) + if self.use_w2: + w2 = self.lokr_w2.to(torch.float) + else: + w2 = (self.lokr_w2_a @ self.lokr_w2_b).to(torch.float) + + weight = make_kron(w1, w2, self.scale) * multiplier + return weight + + def default_forward(self, x): + diff_weight = self.get_diff_weight() + return self.org_forward(x) + F.linear(x, diff_weight) * self.multiplier + + def forward(self, x): + if not self.enabled: + return self.org_forward(x) + return self.default_forward(x) + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + """Create a LoKr network with auto-detected architecture.""" + target_replace_modules, default_excludes = detect_arch_config(unet) + + # merge user exclude_patterns with defaults + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + exclude_patterns.extend(default_excludes) + kwargs["exclude_patterns"] = exclude_patterns + + # extract factor from kwargs + factor = kwargs.pop("factor", -1) + factor = int(factor) + + return lora_module.create_network( + target_replace_modules, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + module_class=LoKrModule, + module_kwargs={"factor": factor}, + **kwargs, + ) + + +def create_network_from_weights( + target_replace_modules: List[str], + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora_module.LoRANetwork: + """Create LoKr network from saved weights (internal).""" + modules_dim = {} + modules_alpha = {} + for key, value in weights_sd.items(): + if "." not in key: + continue + + lora_name = key.split(".")[0] + if "alpha" in key: + modules_alpha[lora_name] = value + elif "lokr_w2_a" in key: + # low-rank mode: dim = w2_a.shape[1] + dim = value.shape[1] + modules_dim[lora_name] = dim + elif "lokr_w2" in key and "lokr_w2_a" not in key and "lokr_w2_b" not in key: + # full matrix mode: set dim large enough to trigger full-matrix path + if lora_name not in modules_dim: + modules_dim[lora_name] = max(value.shape) + + # extract factor for LoKr (user must specify via --network_args factor=N if different from default) + factor = int(kwargs.pop("factor", -1)) + + module_class = LoKrInfModule if for_inference else LoKrModule + module_kwargs = {"factor": factor} + + network = lora_module.LoRANetwork( + target_replace_modules, + "lora_unet", + text_encoders, + unet, + multiplier=multiplier, + modules_dim=modules_dim, + modules_alpha=modules_alpha, + module_class=module_class, + module_kwargs=module_kwargs, + ) + return network + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora_module.LoRANetwork: + """Create LoKr network from saved weights with auto-detected architecture.""" + target_replace_modules, _ = detect_arch_config(unet) + return create_network_from_weights(target_replace_modules, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs) + + +def merge_weights_to_tensor( + model_weight: torch.Tensor, + lora_name: str, + lora_sd: Dict[str, torch.Tensor], + lora_weight_keys: set, + multiplier: float, + calc_device: torch.device, +) -> torch.Tensor: + """Merge LoKr weights directly into a model weight tensor. + + No Module/Network creation needed. Consumed keys are removed from lora_weight_keys. + Returns model_weight unchanged if no matching LoKr keys found. + """ + w1_key = lora_name + ".lokr_w1" + w2_key = lora_name + ".lokr_w2" + w2a_key = lora_name + ".lokr_w2_a" + w2b_key = lora_name + ".lokr_w2_b" + alpha_key = lora_name + ".alpha" + + if w1_key not in lora_weight_keys: + return model_weight + + w1 = lora_sd[w1_key].to(calc_device) + + # determine low-rank vs full matrix mode + if w2a_key in lora_weight_keys: + # low-rank: w2 = w2_a @ w2_b + w2a = lora_sd[w2a_key].to(calc_device) + w2b = lora_sd[w2b_key].to(calc_device) + dim = w2a.shape[1] + consumed_keys = [w1_key, w2a_key, w2b_key, alpha_key] + elif w2_key in lora_weight_keys: + # full matrix mode + w2a = None + w2b = None + dim = None # will use scale=1.0 + consumed_keys = [w1_key, w2_key, alpha_key] + else: + return model_weight + + alpha = lora_sd.get(alpha_key, None) + if alpha is not None and isinstance(alpha, torch.Tensor): + alpha = alpha.item() + + # compute scale + if w2a is not None: + # low-rank mode + if alpha is None: + alpha = dim + scale = alpha / dim + else: + # full matrix mode: scale = 1.0 + scale = 1.0 + + original_dtype = model_weight.dtype + if original_dtype.itemsize == 1: # fp8 + model_weight = model_weight.to(torch.float16) + w1 = w1.to(torch.float16) + if w2a is not None: + w2a, w2b = w2a.to(torch.float16), w2b.to(torch.float16) + + # compute w2 + if w2a is not None: + w2 = w2a @ w2b + else: + w2 = lora_sd[w2_key].to(calc_device) + if original_dtype.itemsize == 1: + w2 = w2.to(torch.float16) + + # ΔW = kron(w1, w2) * scale + diff_weight = make_kron(w1, w2, scale) + model_weight = model_weight + multiplier * diff_weight + + if original_dtype.itemsize == 1: + model_weight = model_weight.to(original_dtype) + + # remove consumed keys + for key in consumed_keys: + lora_weight_keys.discard(key) + + return model_weight diff --git a/src/musubi_tuner/networks/lora.py b/src/musubi_tuner/networks/lora.py new file mode 100644 index 0000000000000000000000000000000000000000..dfc4aa60b05e496c65b1e34921bd265dbb48da18 --- /dev/null +++ b/src/musubi_tuner/networks/lora.py @@ -0,0 +1,1019 @@ +# LoRA network module: currently conv2d is not fully supported +# reference: +# https://github.com/microsoft/LoRA/blob/main/loralib/layers.py +# https://github.com/cloneofsimo/lora/blob/master/lora_diffusion/lora.py + +import ast +import math +import os +import re +from typing import Any, Dict, List, Optional, Type, Union +from transformers import CLIPTextModel +import torch +import torch.nn as nn + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +HUNYUAN_TARGET_REPLACE_MODULES = ["MMDoubleStreamBlock", "MMSingleStreamBlock"] + + +class LoRAModule(torch.nn.Module): + """ + replaces forward method of the original Linear, instead of replacing the original Linear module. + """ + + def __init__( + self, + lora_name, + org_module: torch.nn.Module, + multiplier=1.0, + lora_dim=4, + alpha=1, + dropout=None, + rank_dropout=None, + module_dropout=None, + split_dims: Optional[List[int]] = None, + **kwargs, + ): + """ + if alpha == 0 or None, alpha is rank (no scaling). + + split_dims is used to mimic the split qkv of multi-head attention. + """ + super().__init__() + self.lora_name = lora_name + + if org_module.__class__.__name__ == "Conv2d": + in_dim = org_module.in_channels + out_dim = org_module.out_channels + else: + in_dim = org_module.in_features + out_dim = org_module.out_features + + self.lora_dim = lora_dim + self.split_dims = split_dims + + if split_dims is None: + if org_module.__class__.__name__ == "Conv2d": + kernel_size = org_module.kernel_size + stride = org_module.stride + padding = org_module.padding + self.lora_down = torch.nn.Conv2d(in_dim, self.lora_dim, kernel_size, stride, padding, bias=False) + self.lora_up = torch.nn.Conv2d(self.lora_dim, out_dim, (1, 1), (1, 1), bias=False) + else: + self.lora_down = torch.nn.Linear(in_dim, self.lora_dim, bias=False) + self.lora_up = torch.nn.Linear(self.lora_dim, out_dim, bias=False) + + torch.nn.init.kaiming_uniform_(self.lora_down.weight, a=math.sqrt(5)) + torch.nn.init.zeros_(self.lora_up.weight) + + # LoftQ override: if pre-computed (lora_A, lora_B) are provided, use them + loftq_init_data = kwargs.get("loftq_init_data", None) + if loftq_init_data is not None: + lora_A, lora_B = loftq_init_data + self.lora_down.weight.data.copy_(lora_A) + self.lora_up.weight.data.copy_(lora_B) + else: + # conv2d not supported + assert sum(split_dims) == out_dim, "sum of split_dims must be equal to out_dim" + assert org_module.__class__.__name__ == "Linear", "split_dims is only supported for Linear" + # print(f"split_dims: {split_dims}") + self.lora_down = torch.nn.ModuleList( + [torch.nn.Linear(in_dim, self.lora_dim, bias=False) for _ in range(len(split_dims))] + ) + self.lora_up = torch.nn.ModuleList([torch.nn.Linear(self.lora_dim, split_dim, bias=False) for split_dim in split_dims]) + for lora_down in self.lora_down: + torch.nn.init.kaiming_uniform_(lora_down.weight, a=math.sqrt(5)) + for lora_up in self.lora_up: + torch.nn.init.zeros_(lora_up.weight) + + if type(alpha) == torch.Tensor: + alpha = alpha.detach().float().numpy() # without casting, bf16 causes error + alpha = self.lora_dim if alpha is None or alpha == 0 else alpha + self.scale = alpha / self.lora_dim + self.register_buffer("alpha", torch.tensor(alpha)) # for save/load + + # same as microsoft's + self.multiplier = multiplier + self.org_module = org_module # remove in applying + self.dropout = dropout + self.rank_dropout = rank_dropout + self.module_dropout = module_dropout + + def apply_to(self): + self.org_forward = self.org_module.forward + self.org_module.forward = self.forward + del self.org_module + + def forward(self, x): + org_forwarded = self.org_forward(x) + + # module dropout + if self.module_dropout is not None and self.training: + if torch.rand(1) < self.module_dropout: + return org_forwarded + + if self.split_dims is None: + lx = self.lora_down(x) + + # normal dropout + if self.dropout is not None and self.training: + lx = torch.nn.functional.dropout(lx, p=self.dropout) + + # rank dropout + if self.rank_dropout is not None and self.training: + mask = torch.rand((lx.size(0), self.lora_dim), device=lx.device) > self.rank_dropout + if len(lx.size()) == 3: + mask = mask.unsqueeze(1) # for Text Encoder + elif len(lx.size()) == 4: + mask = mask.unsqueeze(-1).unsqueeze(-1) # for Conv2d + lx = lx * mask + + # scaling for rank dropout: treat as if the rank is changed + scale = self.scale * (1.0 / (1.0 - self.rank_dropout)) # redundant for readability + else: + scale = self.scale + + lx = self.lora_up(lx) + + return org_forwarded + lx * self.multiplier * scale + else: + lxs = [lora_down(x) for lora_down in self.lora_down] + + # normal dropout + if self.dropout is not None and self.training: + lxs = [torch.nn.functional.dropout(lx, p=self.dropout) for lx in lxs] + + # rank dropout + if self.rank_dropout is not None and self.training: + masks = [torch.rand((lx.size(0), self.lora_dim), device=lx.device) > self.rank_dropout for lx in lxs] + for i in range(len(lxs)): + if len(lx.size()) == 3: + masks[i] = masks[i].unsqueeze(1) + elif len(lx.size()) == 4: + masks[i] = masks[i].unsqueeze(-1).unsqueeze(-1) + lxs[i] = lxs[i] * masks[i] + + # scaling for rank dropout: treat as if the rank is changed + scale = self.scale * (1.0 / (1.0 - self.rank_dropout)) # redundant for readability + else: + scale = self.scale + + lxs = [lora_up(lx) for lora_up, lx in zip(self.lora_up, lxs)] + + return org_forwarded + torch.cat(lxs, dim=-1) * self.multiplier * scale + + +class LoRAInfModule(LoRAModule): + def __init__( + self, + lora_name, + org_module: torch.nn.Module, + multiplier=1.0, + lora_dim=4, + alpha=1, + **kwargs, + ): + # no dropout for inference + super().__init__(lora_name, org_module, multiplier, lora_dim, alpha) + + self.org_module_ref = [org_module] # for reference + self.enabled = True + self.network: LoRANetwork = None + + def set_network(self, network): + self.network = network + + def merge_to(self, sd, dtype, device, non_blocking=False): + # extract weight from org_module + org_sd = self.org_module.state_dict() + weight = org_sd["weight"] + org_dtype = weight.dtype + org_device = weight.device + weight = weight.to(device, dtype=torch.float, non_blocking=non_blocking) # for calculation + + if dtype is None: + dtype = org_dtype + if device is None: + device = org_device + + if self.split_dims is None: + # get up/down weight + down_weight = sd["lora_down.weight"].to(device, dtype=torch.float, non_blocking=non_blocking) + up_weight = sd["lora_up.weight"].to(device, dtype=torch.float, non_blocking=non_blocking) + + # merge weight + if len(weight.size()) == 2: + # linear + weight = weight + self.multiplier * (up_weight @ down_weight) * self.scale + elif down_weight.size()[2:4] == (1, 1): + # conv2d 1x1 + weight = ( + weight + + self.multiplier + * (up_weight.squeeze(3).squeeze(2) @ down_weight.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3) + * self.scale + ) + else: + # conv2d 3x3 + conved = torch.nn.functional.conv2d(down_weight.permute(1, 0, 2, 3), up_weight).permute(1, 0, 2, 3) + # logger.info(conved.size(), weight.size(), module.stride, module.padding) + weight = weight + self.multiplier * conved * self.scale + + # set weight to org_module + org_sd["weight"] = weight.to(org_device, dtype=dtype) # back to CPU without non_blocking + self.org_module.load_state_dict(org_sd) + else: + # split_dims + total_dims = sum(self.split_dims) + for i in range(len(self.split_dims)): + # get up/down weight + down_weight = sd[f"lora_down.{i}.weight"].to(device, torch.float, non_blocking=non_blocking) # (rank, in_dim) + up_weight = sd[f"lora_up.{i}.weight"].to(device, torch.float, non_blocking=non_blocking) # (split dim, rank) + + # pad up_weight -> (total_dims, rank) + padded_up_weight = torch.zeros((total_dims, up_weight.size(0)), device=device, dtype=torch.float) + padded_up_weight[sum(self.split_dims[:i]) : sum(self.split_dims[: i + 1])] = up_weight + + # merge weight + weight = weight + self.multiplier * (up_weight @ down_weight) * self.scale + + # set weight to org_module + org_sd["weight"] = weight.to(org_device, dtype) # back to CPU without non_blocking + self.org_module.load_state_dict(org_sd) + + # return weight for merge + def get_weight(self, multiplier=None): + if multiplier is None: + multiplier = self.multiplier + + # get up/down weight from module + up_weight = self.lora_up.weight.to(torch.float) + down_weight = self.lora_down.weight.to(torch.float) + + # pre-calculated weight + if len(down_weight.size()) == 2: + # linear + weight = self.multiplier * (up_weight @ down_weight) * self.scale + elif down_weight.size()[2:4] == (1, 1): + # conv2d 1x1 + weight = ( + self.multiplier + * (up_weight.squeeze(3).squeeze(2) @ down_weight.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3) + * self.scale + ) + else: + # conv2d 3x3 + conved = torch.nn.functional.conv2d(down_weight.permute(1, 0, 2, 3), up_weight).permute(1, 0, 2, 3) + weight = self.multiplier * conved * self.scale + + return weight + + def default_forward(self, x): + # logger.info(f"default_forward {self.lora_name} {x.size()}") + if self.split_dims is None: + lx = self.lora_down(x) + lx = self.lora_up(lx) + return self.org_forward(x) + lx * self.multiplier * self.scale + else: + lxs = [lora_down(x) for lora_down in self.lora_down] + lxs = [lora_up(lx) for lora_up, lx in zip(self.lora_up, lxs)] + return self.org_forward(x) + torch.cat(lxs, dim=-1) * self.multiplier * self.scale + + def forward(self, x): + if not self.enabled: + return self.org_forward(x) + return self.default_forward(x) + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + # add default exclude patterns + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + + # exclude if 'img_mod', 'txt_mod' or 'modulation' in the name + exclude_patterns.append(r".*(img_mod|txt_mod|modulation).*") + + kwargs["exclude_patterns"] = exclude_patterns + + return create_network( + HUNYUAN_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + + +def create_network( + target_replace_modules: List[str], + prefix: str, + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + module_class: Type[object] = None, + module_kwargs: Optional[Dict[str, Any]] = None, + **kwargs, +): + """architecture independent network creation""" + if network_dim is None: + network_dim = 4 # default + if network_alpha is None: + network_alpha = 1.0 + + # extract dim/alpha for conv2d, and block dim + conv_dim = kwargs.get("conv_dim", None) + conv_alpha = kwargs.get("conv_alpha", None) + if conv_dim is not None: + conv_dim = int(conv_dim) + if conv_alpha is None: + conv_alpha = 1.0 + else: + conv_alpha = float(conv_alpha) + + # TODO generic rank/dim setting with regular expression + + # rank/module dropout + rank_dropout = kwargs.get("rank_dropout", None) + if rank_dropout is not None: + rank_dropout = float(rank_dropout) + module_dropout = kwargs.get("module_dropout", None) + if module_dropout is not None: + module_dropout = float(module_dropout) + + # verbose + verbose = kwargs.get("verbose", False) + if verbose is not None: + verbose = True if verbose == "True" else False + + # regular expression for module selection: exclude and include + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is not None and isinstance(exclude_patterns, str): + exclude_patterns = ast.literal_eval(exclude_patterns) + include_patterns = kwargs.get("include_patterns", None) + if include_patterns is not None and isinstance(include_patterns, str): + include_patterns = ast.literal_eval(include_patterns) + + if module_class is None: + module_class = LoRAModule + + # too many arguments ( ^ω^)･･･ + network = LoRANetwork( + target_replace_modules, + prefix, + text_encoders, + unet, + multiplier=multiplier, + lora_dim=network_dim, + alpha=network_alpha, + dropout=neuron_dropout, + rank_dropout=rank_dropout, + module_dropout=module_dropout, + conv_lora_dim=conv_dim, + conv_alpha=conv_alpha, + module_class=module_class, + module_kwargs=module_kwargs, + exclude_patterns=exclude_patterns, + include_patterns=include_patterns, + verbose=verbose, + ) + + loraplus_lr_ratio = kwargs.get("loraplus_lr_ratio", None) + # loraplus_unet_lr_ratio = kwargs.get("loraplus_unet_lr_ratio", None) + # loraplus_text_encoder_lr_ratio = kwargs.get("loraplus_text_encoder_lr_ratio", None) + loraplus_lr_ratio = float(loraplus_lr_ratio) if loraplus_lr_ratio is not None else None + # loraplus_unet_lr_ratio = float(loraplus_unet_lr_ratio) if loraplus_unet_lr_ratio is not None else None + # loraplus_text_encoder_lr_ratio = float(loraplus_text_encoder_lr_ratio) if loraplus_text_encoder_lr_ratio is not None else None + if loraplus_lr_ratio is not None: # or loraplus_unet_lr_ratio is not None or loraplus_text_encoder_lr_ratio is not None: + network.set_loraplus_lr_ratio(loraplus_lr_ratio) # , loraplus_unet_lr_ratio, loraplus_text_encoder_lr_ratio) + + return network + + +class LoRANetwork(torch.nn.Module): + # only supports U-Net (DiT), Text Encoders are not supported + + def __init__( + self, + target_replace_modules: List[str], + prefix: str, + text_encoders: Union[List[CLIPTextModel], CLIPTextModel], + unet: nn.Module, + multiplier: float = 1.0, + lora_dim: int = 4, + alpha: float = 1, + dropout: Optional[float] = None, + rank_dropout: Optional[float] = None, + module_dropout: Optional[float] = None, + conv_lora_dim: Optional[int] = None, + conv_alpha: Optional[float] = None, + module_class: Type[object] = LoRAModule, + module_kwargs: Optional[Dict[str, Any]] = None, + modules_dim: Optional[Dict[str, int]] = None, + modules_alpha: Optional[Dict[str, int]] = None, + exclude_patterns: Optional[List[str]] = None, + include_patterns: Optional[List[str]] = None, + verbose: Optional[bool] = False, + ) -> None: + super().__init__() + self.multiplier = multiplier + + self.lora_dim = lora_dim + self.alpha = alpha + self.conv_lora_dim = conv_lora_dim + self.conv_alpha = conv_alpha + self.dropout = dropout + self.rank_dropout = rank_dropout + self.module_dropout = module_dropout + self.target_replace_modules = target_replace_modules + self.prefix = prefix + self.module_kwargs = module_kwargs or {} + + self.loraplus_lr_ratio = None + # self.loraplus_unet_lr_ratio = None + # self.loraplus_text_encoder_lr_ratio = None + + if modules_dim is not None: + logger.info("create LoRA network from weights") + else: + logger.info(f"create LoRA network. base dim (rank): {lora_dim}, alpha: {alpha}") + logger.info( + f"neuron dropout: p={self.dropout}, rank dropout: p={self.rank_dropout}, module dropout: p={self.module_dropout}" + ) + # if self.conv_lora_dim is not None: + # logger.info( + # f"apply LoRA to Conv2d with kernel size (3,3). dim (rank): {self.conv_lora_dim}, alpha: {self.conv_alpha}" + # ) + # if train_t5xxl: + # logger.info(f"train T5XXL as well") + + # compile regular expression if specified + exclude_re_patterns = [] + if exclude_patterns is not None: + for pattern in exclude_patterns: + try: + re_pattern = re.compile(pattern) + except re.error as e: + logger.error(f"Invalid exclude pattern '{pattern}': {e}") + continue + exclude_re_patterns.append(re_pattern) + + include_re_patterns = [] + has_include_filter = include_patterns is not None + if include_patterns is not None: + for pattern in include_patterns: + try: + re_pattern = re.compile(pattern) + except re.error as e: + logger.error(f"Invalid include pattern '{pattern}': {e}") + continue + include_re_patterns.append(re_pattern) + + # create module instances + def create_modules( + is_unet: bool, + pfx: str, + root_module: torch.nn.Module, + target_replace_mods: Optional[List[str]] = None, + filter: Optional[str] = None, + default_dim: Optional[int] = None, + ) -> List[LoRAModule]: + loras = [] + skipped = [] + for name, module in root_module.named_modules(): + if target_replace_mods is None or module.__class__.__name__ in target_replace_mods: + if target_replace_mods is None: # dirty hack for all modules + module = root_module # search all modules + + for child_name, child_module in module.named_modules(): + is_linear = child_module.__class__.__name__ == "Linear" + is_conv2d = child_module.__class__.__name__ == "Conv2d" + is_conv2d_1x1 = is_conv2d and child_module.kernel_size == (1, 1) + + if is_linear or is_conv2d: + original_name = (name + "." if name else "") + child_name + lora_name = f"{pfx}.{original_name}".replace(".", "_") + + # exclude/include filter + excluded = False + for pattern in exclude_re_patterns: + if pattern.fullmatch(original_name): + excluded = True + break + included = False + for pattern in include_re_patterns: + if pattern.fullmatch(original_name): + included = True + break + if excluded and not included: + if verbose: + logger.info(f"exclude: {original_name}") + continue + if has_include_filter and not included: + if verbose: + logger.info(f"not included: {original_name}") + continue + + # filter by name (not used in the current implementation) + if filter is not None and filter not in lora_name: + continue + + dim = None + alpha = None + + if modules_dim is not None: + # モジュール指定あり + if lora_name in modules_dim: + dim = modules_dim[lora_name] + alpha = modules_alpha[lora_name] + else: + # 通常、すべて対象とする + if is_linear or is_conv2d_1x1: + dim = default_dim if default_dim is not None else self.lora_dim + alpha = self.alpha + elif self.conv_lora_dim is not None: + dim = self.conv_lora_dim + alpha = self.conv_alpha + + if dim is None or dim == 0: + # skipした情報を出力 + if is_linear or is_conv2d_1x1 or (self.conv_lora_dim is not None): + skipped.append(lora_name) + continue + + # Build per-module kwargs, injecting LoftQ data if available + per_module_kwargs = dict(self.module_kwargs) + loftq_data = per_module_kwargs.pop("loftq_data", None) + if loftq_data is not None and lora_name in loftq_data: + per_module_kwargs["loftq_init_data"] = loftq_data[lora_name] + + lora = module_class( + lora_name, + child_module, + self.multiplier, + dim, + alpha, + dropout=dropout, + rank_dropout=rank_dropout, + module_dropout=module_dropout, + **per_module_kwargs, + ) + loras.append(lora) + + if target_replace_mods is None: + break # all modules are searched + return loras, skipped + + # # create LoRA for text encoder + # # it is redundant to create LoRA modules even if they are not used + + self.text_encoder_loras: List[Union[LoRAModule, LoRAInfModule]] = [] + # skipped_te = [] + # for i, text_encoder in enumerate(text_encoders): + # index = i + # if not train_t5xxl and index > 0: # 0: CLIP, 1: T5XXL, so we skip T5XXL if train_t5xxl is False + # break + # logger.info(f"create LoRA for Text Encoder {index+1}:") + # text_encoder_loras, skipped = create_modules(False, index, text_encoder, LoRANetwork.TEXT_ENCODER_TARGET_REPLACE_MODULE) + # logger.info(f"create LoRA for Text Encoder {index+1}: {len(text_encoder_loras)} modules.") + # self.text_encoder_loras.extend(text_encoder_loras) + # skipped_te += skipped + + # create LoRA for U-Net + self.unet_loras: List[Union[LoRAModule, LoRAInfModule]] + self.unet_loras, skipped_un = create_modules(True, prefix, unet, target_replace_modules) + + logger.info(f"create LoRA for U-Net/DiT: {len(self.unet_loras)} modules.") + if verbose: + for lora in self.unet_loras: + logger.info(f"\t{lora.lora_name:50} {lora.lora_dim}, {lora.alpha}") + + skipped = skipped_un + if verbose and len(skipped) > 0: + logger.warning( + f"because dim (rank) is 0, {len(skipped)} LoRA modules are skipped / dim (rank)が0の為、次の{len(skipped)}個のLoRAモジュールはスキップされます:" + ) + for name in skipped: + logger.info(f"\t{name}") + + # assertion + names = set() + for lora in self.text_encoder_loras + self.unet_loras: + assert lora.lora_name not in names, f"duplicated lora name: {lora.lora_name}" + names.add(lora.lora_name) + + def prepare_network(self, args): + """ + called after the network is created + """ + pass + + def set_multiplier(self, multiplier): + self.multiplier = multiplier + for lora in self.text_encoder_loras + self.unet_loras: + lora.multiplier = self.multiplier + + def set_enabled(self, is_enabled): + for lora in self.text_encoder_loras + self.unet_loras: + lora.enabled = is_enabled + + def load_weights(self, file): + if os.path.splitext(file)[1] == ".safetensors": + from safetensors.torch import load_file + + weights_sd = load_file(file) + else: + weights_sd = torch.load(file, map_location="cpu") + + info = self.load_state_dict(weights_sd, False) + return info + + def apply_to( + self, + text_encoders: Optional[nn.Module], + unet: Optional[nn.Module], + apply_text_encoder: bool = True, + apply_unet: bool = True, + ): + if apply_text_encoder: + logger.info(f"enable LoRA for text encoder: {len(self.text_encoder_loras)} modules") + else: + self.text_encoder_loras = [] + + if apply_unet: + logger.info(f"enable LoRA for U-Net: {len(self.unet_loras)} modules") + else: + self.unet_loras = [] + + if len(self.text_encoder_loras) == 0 and len(self.unet_loras) == 0: + logger.error( + "No LoRA modules. Please check `--network_module` and `--network_args`" + " / LoRAモジュールがありません。`--network_module`と`--network_args`を確認してください" + ) + raise RuntimeError("No LoRA modules found") + + for lora in self.text_encoder_loras + self.unet_loras: + lora.apply_to() + self.add_module(lora.lora_name, lora) + + # マージできるかどうかを返す + def is_mergeable(self): + return True + + # TODO refactor to common function with apply_to + def merge_to(self, text_encoders, unet, weights_sd, dtype=None, device=None, non_blocking=False): + from concurrent.futures import ThreadPoolExecutor + + with ThreadPoolExecutor(max_workers=2) as executor: # 2 workers is enough + futures = [] + for lora in self.text_encoder_loras + self.unet_loras: + sd_for_lora = {} + for key in weights_sd.keys(): + if key.startswith(lora.lora_name): + sd_for_lora[key[len(lora.lora_name) + 1 :]] = weights_sd[key] + if len(sd_for_lora) == 0: + logger.info(f"no weight for {lora.lora_name}") + continue + + # lora.merge_to(sd_for_lora, dtype, device) + futures.append(executor.submit(lora.merge_to, sd_for_lora, dtype, device, non_blocking)) + + for future in futures: + future.result() + + logger.info("weights are merged") + + def set_loraplus_lr_ratio(self, loraplus_lr_ratio): # , loraplus_unet_lr_ratio, loraplus_text_encoder_lr_ratio): + self.loraplus_lr_ratio = loraplus_lr_ratio + + logger.info(f"LoRA+ UNet LR Ratio: {self.loraplus_lr_ratio}") + # logger.info(f"LoRA+ Text Encoder LR Ratio: {self.loraplus_text_encoder_lr_ratio or self.loraplus_lr_ratio}") + + def prepare_optimizer_params(self, unet_lr: float = 1e-4, audio_lr=None, lr_args=None, **kwargs): + self.requires_grad_(True) + + # Parse lr_args from CLI format ["pattern=lr", ...] → dict + lr_patterns = {} + if lr_args: + for entry in lr_args: + if "=" not in entry: + raise ValueError(f"Invalid --lr_args entry (expected pattern=lr): {entry}") + pattern, lr_str = entry.split("=", 1) + lr_patterns[pattern] = float(lr_str) + + # If no custom LR config, use original fast path + if not lr_patterns and audio_lr is None: + return self._prepare_optimizer_params_simple(unet_lr) + + # Group LoRA modules by resolved LR + lr_to_params = {} # lr_value → {"lora": {name: param}, "plus": {name: param}} + lr_to_desc = {} # lr_value → description string + + for lora in self.unet_loras: + resolved_lr = unet_lr # default + desc = "video" + + # Check lr_args patterns first (highest priority) + matched_pattern = False + for pattern, pattern_lr in lr_patterns.items(): + if re.search(pattern, lora.lora_name): + resolved_lr = pattern_lr + desc = pattern + matched_pattern = True + break + + # If no pattern matched, check audio_lr + if not matched_pattern and audio_lr is not None: + if "audio_" in lora.lora_name: + resolved_lr = audio_lr + desc = "audio" + + # Add params to the correct LR group + group = lr_to_params.setdefault(resolved_lr, {"lora": {}, "plus": {}}) + lr_to_desc.setdefault(resolved_lr, desc) + for name, param in lora.named_parameters(): + key = f"{lora.lora_name}.{name}" + if self.loraplus_lr_ratio is not None and "lora_up" in name: + group["plus"][key] = param + else: + group["lora"][key] = param + + # Build final param groups + all_params = [] + lr_descriptions = [] + for lr_val in sorted(lr_to_params.keys()): + groups = lr_to_params[lr_val] + desc = lr_to_desc[lr_val] + for key in ("lora", "plus"): + if not groups[key]: + continue + param_data = {"params": list(groups[key].values()), "lr": lr_val} + if key == "plus" and self.loraplus_lr_ratio: + param_data["lr"] = lr_val * self.loraplus_lr_ratio + all_params.append(param_data) + suffix = " plus" if key == "plus" else "" + lr_descriptions.append(f"unet_{desc}{suffix}") + + # Log group breakdown + logger.info(f"LR groups: {len(all_params)} groups created") + for param_data, desc in zip(all_params, lr_descriptions): + logger.info(f" {desc}: lr={param_data['lr']}, {len(param_data['params'])} params") + + return all_params, lr_descriptions + + def _prepare_optimizer_params_simple(self, unet_lr: float = 1e-4): + """Original single-group optimizer param assembly (no per-module LR).""" + all_params = [] + lr_descriptions = [] + + def assemble_params(loras, lr, loraplus_ratio): + param_groups = {"lora": {}, "plus": {}} + for lora in loras: + for name, param in lora.named_parameters(): + if loraplus_ratio is not None and "lora_up" in name: + param_groups["plus"][f"{lora.lora_name}.{name}"] = param + else: + param_groups["lora"][f"{lora.lora_name}.{name}"] = param + + if loraplus_ratio is not None and len(param_groups["plus"]) == 0: + logger.warning("LoRA+ is not effective for this network type (no 'lora_up' parameters found)") + + params = [] + descriptions = [] + for key in param_groups.keys(): + param_data = {"params": param_groups[key].values()} + + if len(param_data["params"]) == 0: + continue + + if lr is not None: + if key == "plus": + param_data["lr"] = lr * loraplus_ratio + else: + param_data["lr"] = lr + + if param_data.get("lr", None) == 0 or param_data.get("lr", None) is None: + logger.info("NO LR skipping!") + continue + + params.append(param_data) + descriptions.append("plus" if key == "plus" else "") + + return params, descriptions + + if self.unet_loras: + params, descriptions = assemble_params(self.unet_loras, unet_lr, self.loraplus_lr_ratio) + all_params.extend(params) + lr_descriptions.extend(["unet" + (" " + d if d else "") for d in descriptions]) + + return all_params, lr_descriptions + + def enable_gradient_checkpointing(self): + # not supported + pass + + def prepare_grad_etc(self, unet): + self.requires_grad_(True) + + def on_epoch_start(self, unet): + self.train() + + def on_step_start(self): + pass + + def get_trainable_params(self): + return self.parameters() + + def save_weights(self, file, dtype, metadata): + if metadata is not None and len(metadata) == 0: + metadata = None + + state_dict = self.state_dict() + + if dtype is not None: + for key in list(state_dict.keys()): + v = state_dict[key] + v = v.detach().clone().to("cpu").to(dtype) + state_dict[key] = v + + if os.path.splitext(file)[1] == ".safetensors": + from safetensors.torch import save_file + from musubi_tuner.utils import model_utils + + # Precalculate model hashes to save time on indexing + if metadata is None: + metadata = {} + model_hash, legacy_hash = model_utils.precalculate_safetensors_hashes(state_dict, metadata) + metadata["sshs_model_hash"] = model_hash + metadata["sshs_legacy_hash"] = legacy_hash + + save_file(state_dict, file, metadata) + else: + torch.save(state_dict, file) + + def backup_weights(self): + # 重みのバックアップを行う + loras: List[LoRAInfModule] = self.text_encoder_loras + self.unet_loras + for lora in loras: + org_module = lora.org_module_ref[0] + if not hasattr(org_module, "_lora_org_weight"): + sd = org_module.state_dict() + org_module._lora_org_weight = sd["weight"].detach().clone() + org_module._lora_restored = True + + def restore_weights(self): + # 重みのリストアを行う + loras: List[LoRAInfModule] = self.text_encoder_loras + self.unet_loras + for lora in loras: + org_module = lora.org_module_ref[0] + if not org_module._lora_restored: + sd = org_module.state_dict() + sd["weight"] = org_module._lora_org_weight + org_module.load_state_dict(sd) + org_module._lora_restored = True + + def pre_calculation(self): + # 事前計算を行う + loras: List[LoRAInfModule] = self.text_encoder_loras + self.unet_loras + for lora in loras: + org_module = lora.org_module_ref[0] + sd = org_module.state_dict() + + org_weight = sd["weight"] + lora_weight = lora.get_weight().to(org_weight.device, dtype=org_weight.dtype) + sd["weight"] = org_weight + lora_weight + assert sd["weight"].shape == org_weight.shape + org_module.load_state_dict(sd) + + org_module._lora_restored = False + lora.enabled = False + + def apply_max_norm_regularization(self, max_norm_value, device): + downkeys = [] + upkeys = [] + alphakeys = [] + norms = [] + keys_scaled = 0 + + state_dict = self.state_dict() + + # guard: only supported for LoRA (lora_down/lora_up parameterization) + if not any("lora_down" in k and "weight" in k for k in state_dict.keys()): + logger.warning("max_norm_regularization is only supported for LoRA") + return 0, 0.0, 0.0 + + for key in state_dict.keys(): + if "lora_down" in key and "weight" in key: + downkeys.append(key) + upkeys.append(key.replace("lora_down", "lora_up")) + alphakeys.append(key.replace("lora_down.weight", "alpha")) + + for i in range(len(downkeys)): + down = state_dict[downkeys[i]].to(device) + up = state_dict[upkeys[i]].to(device) + alpha = state_dict[alphakeys[i]].to(device) + dim = down.shape[0] + scale = alpha / dim + + if up.shape[2:] == (1, 1) and down.shape[2:] == (1, 1): + updown = (up.squeeze(2).squeeze(2) @ down.squeeze(2).squeeze(2)).unsqueeze(2).unsqueeze(3) + elif up.shape[2:] == (3, 3) or down.shape[2:] == (3, 3): + updown = torch.nn.functional.conv2d(down.permute(1, 0, 2, 3), up).permute(1, 0, 2, 3) + else: + updown = up @ down + + updown *= scale + + norm = updown.norm().clamp(min=max_norm_value / 2) + desired = torch.clamp(norm, max=max_norm_value) + ratio = desired.cpu() / norm.cpu() + sqrt_ratio = ratio**0.5 + if ratio != 1: + keys_scaled += 1 + state_dict[upkeys[i]] *= sqrt_ratio + state_dict[downkeys[i]] *= sqrt_ratio + scalednorm = updown.norm() * ratio + norms.append(scalednorm.item()) + + return keys_scaled, sum(norms) / len(norms), max(norms) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> LoRANetwork: + return create_network_from_weights( + HUNYUAN_TARGET_REPLACE_MODULES, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs + ) + + +# Create network from weights for inference, weights are not loaded here (because can be merged) +def create_network_from_weights( + target_replace_modules: List[str], + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + module_class: Optional[Type[object]] = None, + module_kwargs: Optional[Dict[str, Any]] = None, + **kwargs, +) -> LoRANetwork: + # get dim/alpha mapping + modules_dim = {} + modules_alpha = {} + for key, value in weights_sd.items(): + if "." not in key: + continue + + lora_name = key.split(".")[0] + if "alpha" in key: + modules_alpha[lora_name] = value + elif "lora_down" in key: + dim = value.shape[0] + modules_dim[lora_name] = dim + # logger.info(lora_name, value.size(), dim) + + if module_class is None: + module_class = LoRAInfModule if for_inference else LoRAModule + + network = LoRANetwork( + target_replace_modules, + "lora_unet", + text_encoders, + unet, + multiplier=multiplier, + modules_dim=modules_dim, + modules_alpha=modules_alpha, + module_class=module_class, + module_kwargs=module_kwargs, + ) + return network diff --git a/src/musubi_tuner/networks/lora_flux.py b/src/musubi_tuner/networks/lora_flux.py new file mode 100644 index 0000000000000000000000000000000000000000..d922ea6b3bb72302bbdd1ac0b62b8825d55f3d3b --- /dev/null +++ b/src/musubi_tuner/networks/lora_flux.py @@ -0,0 +1,65 @@ +# LoRA module for FLUX.1 Kontext + +import ast +from typing import Dict, List, Optional +import torch +import torch.nn as nn + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +import musubi_tuner.networks.lora as lora + + +FLUX_KONTEXT_TARGET_REPLACE_MODULES = ["DoubleStreamBlock", "SingleStreamBlock"] + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + # add default exclude patterns + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [r".*(img_mod\.lin|txt_mod\.lin|modulation\.lin).*"] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + + # exclude if 'norm' in the name of the module + exclude_patterns.append(r".*(norm).*") + + kwargs["exclude_patterns"] = exclude_patterns + + return lora.create_network( + FLUX_KONTEXT_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora.LoRANetwork: + return lora.create_network_from_weights( + FLUX_KONTEXT_TARGET_REPLACE_MODULES, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs + ) diff --git a/src/musubi_tuner/networks/lora_flux_2.py b/src/musubi_tuner/networks/lora_flux_2.py new file mode 100644 index 0000000000000000000000000000000000000000..27ddefe58eee58112535f5330470d8606d1dfcfd --- /dev/null +++ b/src/musubi_tuner/networks/lora_flux_2.py @@ -0,0 +1,65 @@ +# LoRA module for FLUX.2 + +import ast +from typing import Dict, List, Optional +import torch +import torch.nn as nn + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +import musubi_tuner.networks.lora as lora + + +FLUX_2_TARGET_REPLACE_MODULES = ["DoubleStreamBlock", "SingleStreamBlock"] + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + # add default exclude patterns + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [r".*(img_mod\.lin|txt_mod\.lin|modulation\.lin).*"] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + + # exclude if 'norm' in the name of the module + exclude_patterns.append(r".*(norm).*") + + kwargs["exclude_patterns"] = exclude_patterns + + return lora.create_network( + FLUX_2_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora.LoRANetwork: + return lora.create_network_from_weights( + FLUX_2_TARGET_REPLACE_MODULES, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs + ) diff --git a/src/musubi_tuner/networks/lora_framepack.py b/src/musubi_tuner/networks/lora_framepack.py new file mode 100644 index 0000000000000000000000000000000000000000..e20208f8044eab2ea856a60743197dcdd93b3693 --- /dev/null +++ b/src/musubi_tuner/networks/lora_framepack.py @@ -0,0 +1,65 @@ +# LoRA module for FramePack + +import ast +from typing import Dict, List, Optional +import torch +import torch.nn as nn + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +import musubi_tuner.networks.lora as lora + + +FRAMEPACK_TARGET_REPLACE_MODULES = ["HunyuanVideoTransformerBlock", "HunyuanVideoSingleTransformerBlock"] + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + # add default exclude patterns + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + + # exclude if 'norm' in the name of the module + exclude_patterns.append(r".*(norm).*") + + kwargs["exclude_patterns"] = exclude_patterns + + return lora.create_network( + FRAMEPACK_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora.LoRANetwork: + return lora.create_network_from_weights( + FRAMEPACK_TARGET_REPLACE_MODULES, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs + ) diff --git a/src/musubi_tuner/networks/lora_hv_1_5.py b/src/musubi_tuner/networks/lora_hv_1_5.py new file mode 100644 index 0000000000000000000000000000000000000000..7e4e4d86c80842f842c49fe0b399b5ccf3665d66 --- /dev/null +++ b/src/musubi_tuner/networks/lora_hv_1_5.py @@ -0,0 +1,65 @@ +# LoRA module for Hunyuan Video 1.5 + +import ast +from typing import Dict, List, Optional +import torch +import torch.nn as nn + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +import musubi_tuner.networks.lora as lora + + +HV_1_5_IMAGE_TARGET_REPLACE_MODULES = ["MMDoubleStreamBlock"] + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + # add default exclude patterns + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + + # exclude if '_mod_' in the name of the module (modulation) + exclude_patterns.append(r".*(_in).*") + + kwargs["exclude_patterns"] = exclude_patterns + + return lora.create_network( + HV_1_5_IMAGE_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora.LoRANetwork: + return lora.create_network_from_weights( + HV_1_5_IMAGE_TARGET_REPLACE_MODULES, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs + ) diff --git a/src/musubi_tuner/networks/lora_kandinsky.py b/src/musubi_tuner/networks/lora_kandinsky.py new file mode 100644 index 0000000000000000000000000000000000000000..345cff6fba28dc570ba00ade6924f36b56fb2db9 --- /dev/null +++ b/src/musubi_tuner/networks/lora_kandinsky.py @@ -0,0 +1,83 @@ +# LoRA module for Kandinsky 5 DiT + +import ast +from typing import Dict, List, Optional +import torch +import torch.nn as nn + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +import musubi_tuner.networks.lora as lora + + +KANDINSKY5_TARGET_REPLACE_MODULES = ["TransformerEncoderBlock", "TransformerDecoderBlock"] + + +def _prepare_include_patterns(include_patterns: Optional[str]) -> List[str]: + if include_patterns is None: + # Default to the same modules targeted in the reference trainer + return [ + r".*self_attention\.to_query.*", + r".*self_attention\.to_key.*", + r".*self_attention\.to_value.*", + r".*self_attention\.out_layer.*", + r".*cross_attention\.to_query.*", + r".*cross_attention\.to_key.*", + r".*cross_attention\.to_value.*", + r".*cross_attention\.out_layer.*", + r".*feed_forward\.in_layer.*", + r".*feed_forward\.out_layer.*", + ] + return ast.literal_eval(include_patterns) + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + include_patterns = _prepare_include_patterns(kwargs.get("include_patterns", None)) + kwargs["include_patterns"] = include_patterns + + # Exclude modulation layers by default to mirror the reference targeting + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [r".*modulation.*"] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + exclude_patterns.append(r".*modulation.*") + kwargs["exclude_patterns"] = exclude_patterns + + return lora.create_network( + KANDINSKY5_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora.LoRANetwork: + return lora.create_network_from_weights( + KANDINSKY5_TARGET_REPLACE_MODULES, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs + ) diff --git a/src/musubi_tuner/networks/lora_ltx2.py b/src/musubi_tuner/networks/lora_ltx2.py new file mode 100644 index 0000000000000000000000000000000000000000..620ff95a5c57dd33312e89ffd983b52e6cfb7932 --- /dev/null +++ b/src/musubi_tuner/networks/lora_ltx2.py @@ -0,0 +1,791 @@ +from __future__ import annotations + +import ast +import logging +import types +from typing import Dict, List, Optional + +import torch +import torch.nn as nn + +import musubi_tuner.networks.lora as lora +from musubi_tuner.ltx_2.components.patchifiers import get_pixel_coords +from musubi_tuner.ltx_2.guidance.perturbations import BatchedPerturbationConfig +from musubi_tuner.ltx_2.model.transformer.modality import Modality +from musubi_tuner.ltx_2.types import AudioLatentShape, SpatioTemporalScaleFactors, VideoLatentShape + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +def _split_av_context( + model: nn.Module, context: torch.Tensor +) -> tuple[torch.Tensor, torch.Tensor]: + """Split a concatenated AV context tensor into (video_context, audio_context). + + LTX-2.0 (caption_proj_before_connector=False): context is raw text embeddings + [video(cc) | audio(cc)] where cc = caption_projection.linear_1.in_features. + + LTX-2.3 (caption_proj_before_connector=True): the feature extractor already + projects to [video(cross_attention_dim) | audio(audio_cross_attention_dim)]. + + Falls back to an equal half-split when dims cannot be determined from the model. + """ + split_video_dim: int | None = None + split_audio_dim: int | None = None + if bool(getattr(model, "caption_proj_before_connector", False)): + split_video_dim = getattr(model, "cross_attention_dim", None) + split_audio_dim = getattr(model, "audio_cross_attention_dim", None) + else: + cap_proj = getattr(model, "caption_projection", None) + if cap_proj is not None: + lin1 = getattr(cap_proj, "linear_1", None) + if lin1 is not None: + cc = getattr(lin1, "in_features", None) + if isinstance(cc, int) and cc > 0: + split_video_dim = cc + split_audio_dim = cc + if ( + isinstance(split_video_dim, int) + and isinstance(split_audio_dim, int) + and split_video_dim > 0 + and split_audio_dim > 0 + ): + expected_total = split_video_dim + split_audio_dim + if expected_total == context.shape[-1]: + return ( + context[..., :split_video_dim], + context[..., split_video_dim : split_video_dim + split_audio_dim], + ) + raise ValueError( + "Context hidden size mismatch for AV split: " + f"got {context.shape[-1]}, expected {expected_total} " + f"(video={split_video_dim}, audio={split_audio_dim})." + ) + if context.shape[-1] % 2 == 0: + half = context.shape[-1] // 2 + return context[..., :half], context[..., half:] + return context, context + + +def _patch_lora_load_state_dict_for_audio(network: lora.LoRANetwork) -> lora.LoRANetwork: + original = network.load_state_dict + + def _filter_audio_keys(keys: List[str]) -> List[str]: + return [k for k in keys if "audio_" not in k] + + def _load_state_dict(self, state_dict, strict: bool = True): + result = original(state_dict, strict=False) + missing = list(getattr(result, "missing_keys", [])) + unexpected = list(getattr(result, "unexpected_keys", [])) + non_audio_missing = _filter_audio_keys(missing) + non_audio_unexpected = _filter_audio_keys(unexpected) + if non_audio_missing: + raise RuntimeError( + f"Missing non-audio LoRA keys in state_dict: {non_audio_missing[:10]}" + ) + if non_audio_unexpected: + raise RuntimeError( + f"Unexpected non-audio LoRA keys in state_dict: {non_audio_unexpected[:10]}" + ) + if missing and not non_audio_missing: + logger.warning( + "LTX2 LoRA: missing audio keys in checkpoint; initializing audio LoRA weights." + ) + if unexpected and not non_audio_unexpected: + logger.warning( + "LTX2 LoRA: unexpected audio keys in checkpoint; ignoring audio LoRA weights." + ) + try: + incompatible = torch.nn.modules.module._IncompatibleKeys( # type: ignore[attr-defined] + missing_keys=non_audio_missing, + unexpected_keys=non_audio_unexpected, + ) + return incompatible + except Exception: + return result + + network.load_state_dict = types.MethodType(_load_state_dict, network) + return network + + +class LTX2Wrapper(nn.Module): + def __init__( + self, + model: nn.Module, + *, + patch_size: int = 1, + audio_patch_size: int = 1, + sample_rate: int = 16000, + hop_length: int = 160, + audio_latent_downsample_factor: int = 4, + is_causal_audio: bool = True, + ) -> None: + super().__init__() + self.model = model + from musubi_tuner.ltx_2.components.patchifiers import AudioPatchifier, VideoLatentPatchifier + + self._video_patchifier = VideoLatentPatchifier(patch_size=patch_size) + self._audio_patchifier = AudioPatchifier( + patch_size=audio_patch_size, + sample_rate=sample_rate, + hop_length=hop_length, + audio_latent_downsample_factor=audio_latent_downsample_factor, + is_causal=is_causal_audio, + ) + self.patch_size = patch_size + + def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False, **kwargs): + if hasattr(self.model, "enable_gradient_checkpointing"): + # LTX2 core model supports blocks_to_checkpoint when provided. + weight_cpu_offloading = kwargs.get("weight_cpu_offloading", False) + blocks_to_checkpoint = kwargs.get("blocks_to_checkpoint", None) + return self.model.enable_gradient_checkpointing( + activation_cpu_offloading, + weight_cpu_offloading=weight_cpu_offloading, + blocks_to_checkpoint=blocks_to_checkpoint, + ) + if hasattr(self.model, "set_gradient_checkpointing"): + self.model.set_gradient_checkpointing(True) + if hasattr(self.model, "activation_cpu_offloading"): + self.model.activation_cpu_offloading = activation_cpu_offloading + return None + raise AttributeError("Underlying LTX2 model does not support gradient checkpointing") + + def disable_gradient_checkpointing(self): + if hasattr(self.model, "disable_gradient_checkpointing"): + return self.model.disable_gradient_checkpointing() + if hasattr(self.model, "set_gradient_checkpointing"): + self.model.set_gradient_checkpointing(False) + if hasattr(self.model, "activation_cpu_offloading"): + self.model.activation_cpu_offloading = False + return None + raise AttributeError("Underlying LTX2 model does not support gradient checkpointing") + + def enable_block_swap( + self, blocks_to_swap: int, device: torch.device, supports_backward: bool, use_pinned_memory: bool = False, swap_norms: bool = False + ): + return self.model.enable_block_swap(blocks_to_swap, device, supports_backward, use_pinned_memory, swap_norms=swap_norms) + + def move_to_device_except_swap_blocks(self, device: torch.device): + return self.model.move_to_device_except_swap_blocks(device) + + def prepare_block_swap_before_forward(self): + return self.model.prepare_block_swap_before_forward() + + def switch_block_swap_for_inference(self): + if hasattr(self.model, "switch_block_swap_for_inference"): + return self.model.switch_block_swap_for_inference() + return None + + def switch_block_swap_for_training(self): + if hasattr(self.model, "switch_block_swap_for_training"): + return self.model.switch_block_swap_for_training() + return None + + def __getattr__(self, name: str): + try: + return super().__getattr__(name) + except AttributeError: + return getattr(self.model, name) + + def forward_modalities( + self, + video_modality: Optional[Modality], + audio_modality: Optional[Modality] = None, + perturbations: Optional[BatchedPerturbationConfig] = None, + ): + ref_modality = video_modality if video_modality is not None else audio_modality + if ref_modality is None: + raise ValueError("Expected at least one modality for forward_modalities") + if perturbations is None: + perturbations = BatchedPerturbationConfig.empty(int(ref_modality.latent.shape[0])) + return self.model(video_modality, audio_modality, perturbations) + + def forward( + self, + x, + *, + timestep, + context, + attention_mask=None, + frame_rate: int = 25, + transformer_options=None, + audio_only: bool = False, + video_enabled: Optional[bool] = None, + audio_enabled: Optional[bool] = None, + **kwargs, + ): + if isinstance(x, (list, tuple)): + if len(x) != 2: + raise ValueError("Expected x to be [video_latents, audio_latents] for AV mode") + video_latents, audio_latents = x + else: + video_latents, audio_latents = x, None + + model_type = getattr(self.model, "model_type", None) + model_video_enabled = bool(model_type.is_video_enabled()) if model_type is not None else True + model_audio_enabled = bool(model_type.is_audio_enabled()) if model_type is not None else True + + if audio_only: + if audio_latents is None: + raise ValueError("audio_only=True requires audio_latents") + if video_latents is None and model_video_enabled: + in_channels = getattr(self.model, "in_channels", None) + if in_channels is None: + raise ValueError("audio_only=True requires model.in_channels to create dummy video latents") + bsz = int(audio_latents.shape[0]) + video_latents = torch.zeros( + (bsz, int(in_channels), 1, 1, 1), + device=audio_latents.device, + dtype=audio_latents.dtype, + ) + + if not model_audio_enabled and audio_latents is not None: + raise ValueError("Audio latents were provided but the loaded model has no audio branch") + if not model_video_enabled and not audio_only: + raise ValueError("Loaded audio-only transformer requires audio_only=True") + + if model_video_enabled: + if not isinstance(video_latents, torch.Tensor) or video_latents.dim() != 5: + raise ValueError(f"Expected video latents shape [B, C, F, H, W], got: {getattr(video_latents, 'shape', None)}") + elif video_latents is not None and (not isinstance(video_latents, torch.Tensor) or video_latents.dim() != 5): + raise ValueError(f"Expected video latents shape [B, C, F, H, W], got: {getattr(video_latents, 'shape', None)}") + + ref_latents = video_latents if isinstance(video_latents, torch.Tensor) else audio_latents + if not isinstance(ref_latents, torch.Tensor): + raise ValueError("Expected at least one latent tensor (video or audio) to be present") + + bsz = int(ref_latents.shape[0]) + vch = vframes = vheight = vwidth = None + if isinstance(video_latents, torch.Tensor): + _, vch, vframes, vheight, vwidth = video_latents.shape + + def _to_timestep(ts_value, *, name: str) -> torch.Tensor: + if isinstance(ts_value, torch.Tensor): + ts = ts_value + else: + ts = torch.tensor(ts_value, device=ref_latents.device, dtype=ref_latents.dtype) + if ts.dim() == 0: + ts = ts.view(1, 1) + elif ts.dim() == 1: + ts = ts.view(-1, 1) + elif ts.dim() == 2: + pass + else: + raise ValueError(f"Unexpected {name} shape: {tuple(ts.shape)}") + if ts.shape[0] == 1 and bsz != 1: + ts = ts.expand(bsz, ts.shape[1]) + if ts.shape[0] != bsz: + raise ValueError(f"Expected {name} batch size {bsz}, got {ts.shape[0]}") + return ts.to(device=ref_latents.device, dtype=ref_latents.dtype) + + timestep_video = _to_timestep(timestep, name="timestep") + audio_timestep = kwargs.get("audio_timestep") + timestep_audio = _to_timestep(audio_timestep, name="audio_timestep") if audio_timestep is not None else timestep_video + + # Prompt AdaLN expects per-sample sigma. Collapse token-wise timesteps when present. + def _to_sigma(ts: torch.Tensor, *, name: str) -> torch.Tensor: + if ts.dim() == 2: + if ts.shape[1] == 1: + sigma = ts[:, 0] + else: + sigma = ts.to(dtype=torch.float32).mean(dim=1) + elif ts.dim() == 1: + sigma = ts + else: + raise ValueError(f"Unexpected {name} shape: {tuple(ts.shape)}") + if sigma.shape[0] != bsz: + raise ValueError(f"Expected {name} batch size {bsz}, got {sigma.shape[0]}") + return sigma.to(device=ref_latents.device, dtype=ref_latents.dtype) + + sigma = _to_sigma(timestep_video, name="timestep") + audio_sigma = _to_sigma(timestep_audio, name="audio_timestep") + + video_tokens = None + video_timesteps = None + video_positions = None + a2v_cross_attention_mask = None + if model_video_enabled: + video_tokens = self._video_patchifier.patchify(video_latents) + video_seq_len = video_tokens.shape[1] + if timestep_video.shape[1] == 1: + video_timesteps = timestep_video.expand(bsz, video_seq_len) + elif timestep_video.shape[1] == video_seq_len: + video_timesteps = timestep_video + else: + raise ValueError( + f"timestep shape mismatch for video tokens: got {tuple(timestep_video.shape)}, " + f"expected second dim 1 or {video_seq_len}" + ) + + video_conditioning_mask = None + if isinstance(transformer_options, dict): + video_conditioning_mask = transformer_options.get("video_conditioning_mask") + if video_conditioning_mask is not None: + if not isinstance(video_conditioning_mask, torch.Tensor): + raise TypeError(f"Expected video_conditioning_mask to be a torch.Tensor, got: {type(video_conditioning_mask)}") + if video_conditioning_mask.shape != (bsz, video_seq_len): + raise ValueError( + f"video_conditioning_mask shape mismatch: got {tuple(video_conditioning_mask.shape)}, expected {(bsz, video_seq_len)}" + ) + video_conditioning_mask = video_conditioning_mask.to(device=video_tokens.device, dtype=torch.bool) + video_timesteps = torch.where(video_conditioning_mask, torch.zeros_like(video_timesteps), video_timesteps) + + latent_coords = self._video_patchifier.get_patch_grid_bounds( + output_shape=VideoLatentShape( + batch=bsz, + channels=vch, + frames=vframes, + height=vheight, + width=vwidth, + ), + device=video_latents.device, + ) + video_positions = get_pixel_coords( + latent_coords=latent_coords, + scale_factors=SpatioTemporalScaleFactors.default(), + causal_fix=True, + ).to(dtype=video_latents.dtype) + video_positions[:, 0, ...] = video_positions[:, 0, ...] / float(frame_rate) + if isinstance(transformer_options, dict): + video_positions_override = transformer_options.get("video_positions_override") + if isinstance(video_positions_override, torch.Tensor): + if video_positions_override.shape != video_positions.shape: + raise ValueError( + "video_positions_override shape mismatch: " + f"got {tuple(video_positions_override.shape)}, expected {tuple(video_positions.shape)}" + ) + video_positions = video_positions_override.to(device=video_positions.device, dtype=video_positions.dtype) + a2v_cross_attention_mask = transformer_options.get("a2v_cross_attention_mask") + + video_context = context + audio_context = context + audio_context_mask = attention_mask + v2a_cross_attention_mask = None + if ( + model_video_enabled + and not audio_only + and audio_latents is not None + and isinstance(context, torch.Tensor) + ): + video_context, audio_context = _split_av_context(self.model, context) + + video_modality = None + if model_video_enabled: + video_self_attention_mask = None + if isinstance(transformer_options, dict): + video_self_attention_mask = transformer_options.get("self_attention_mask") + video_modality = Modality( + enabled=(not audio_only if video_enabled is None else bool(video_enabled)), + latent=video_tokens, + timesteps=video_timesteps, + positions=video_positions, + context=video_context, + sigma=sigma, + context_mask=attention_mask, + attention_mask=video_self_attention_mask, + a2v_cross_attention_mask=a2v_cross_attention_mask, + ) + + audio_modality = None + audio_shape = None + if audio_latents is not None: + if not isinstance(audio_latents, torch.Tensor) or audio_latents.dim() != 4: + raise ValueError(f"Expected audio latents shape [B, C, T, F], got: {getattr(audio_latents, 'shape', None)}") + + absz, ach, at, af = audio_latents.shape + if absz != bsz: + raise ValueError(f"Batch mismatch: video B={bsz}, audio B={absz}") + + audio_tokens = self._audio_patchifier.patchify(audio_latents) + audio_seq_len = audio_tokens.shape[1] + if timestep_audio.shape[1] == 1: + audio_timesteps = timestep_audio.expand(bsz, audio_seq_len) + elif timestep_audio.shape[1] == audio_seq_len: + audio_timesteps = timestep_audio + else: + raise ValueError( + f"audio_timestep shape mismatch for audio tokens: got {tuple(timestep_audio.shape)}, " + f"expected second dim 1 or {audio_seq_len}" + ) + + audio_shape = AudioLatentShape(batch=bsz, channels=ach, frames=at, mel_bins=af) + audio_positions = self._audio_patchifier.get_patch_grid_bounds(audio_shape, device=audio_latents.device) + if isinstance(transformer_options, dict): + audio_positions_override = transformer_options.get("audio_positions_override") + if isinstance(audio_positions_override, torch.Tensor): + if audio_positions_override.shape != audio_positions.shape: + raise ValueError( + "audio_positions_override shape mismatch: " + f"got {tuple(audio_positions_override.shape)}, expected {tuple(audio_positions.shape)}" + ) + audio_positions = audio_positions_override.to(device=audio_positions.device, dtype=audio_positions.dtype) + if "audio_context_mask" in transformer_options: + audio_context_mask = transformer_options.get("audio_context_mask") + v2a_cross_attention_mask = transformer_options.get("v2a_cross_attention_mask") + + audio_modality = Modality( + enabled=(True if audio_enabled is None else bool(audio_enabled)), + latent=audio_tokens, + timesteps=audio_timesteps, + positions=audio_positions.to(dtype=audio_latents.dtype), + context=audio_context, + sigma=audio_sigma, + context_mask=audio_context_mask, + v2a_cross_attention_mask=v2a_cross_attention_mask, + ) + + perturbations = BatchedPerturbationConfig.empty(bsz) + video_pred_tokens, audio_pred_tokens = self.model(video_modality, audio_modality, perturbations) + + if model_video_enabled: + video_pred = self._video_patchifier.unpatchify( + video_pred_tokens, + output_shape=VideoLatentShape( + batch=bsz, + channels=vch, + frames=vframes, + height=vheight, + width=vwidth, + ), + ) + elif isinstance(video_latents, torch.Tensor): + video_pred = torch.zeros_like(video_latents) + else: + channel_count = int(getattr(self.model, "in_channels", 1) or 1) + video_pred = torch.zeros( + (bsz, channel_count, 1, 1, 1), + device=ref_latents.device, + dtype=ref_latents.dtype, + ) + + if audio_latents is None: + return video_pred + + audio_pred = self._audio_patchifier.unpatchify(audio_pred_tokens, output_shape=audio_shape) + return [video_pred, audio_pred] + + +def load_ltx2_transformer( + model_path: str, + *, + device: torch.device, + dtype: torch.dtype, + audio_video: bool = False, +) -> nn.Module: + from musubi_tuner.ltx_2.loader.single_gpu_model_builder import SingleGPUModelBuilder + from musubi_tuner.ltx_2.model.transformer.model_configurator import ( + LTXModelConfigurator, + LTXVideoOnlyModelConfigurator, + LTXV_MODEL_COMFY_RENAMING_MAP, + ) + + configurator = LTXModelConfigurator if audio_video else LTXVideoOnlyModelConfigurator + return SingleGPUModelBuilder( + model_path=str(model_path), + model_class_configurator=configurator, + model_sd_ops=LTXV_MODEL_COMFY_RENAMING_MAP, + ).build(device=device, dtype=dtype) + + +def load_ltx2_wrapper( + model_path: str, + *, + device: torch.device, + dtype: torch.dtype, + audio_video: bool = False, + patch_size: int = 1, +) -> nn.Module: + model = load_ltx2_transformer(model_path, device=device, dtype=dtype, audio_video=audio_video) + return LTX2Wrapper(model, patch_size=patch_size) + + +# Target module class names to search for LoRA-applicable layers +# Only BasicAVTransformerBlock is targeted - it contains all attention modules: +# - attn1 (video self-attention), attn2 (video cross-attention to text) +# - audio_attn1, audio_attn2 (audio attention) +# - audio_to_video_attn, video_to_audio_attn (cross-modal attention) +# - ff, audio_ff (feed-forward, if included via patterns) +LTX2_TARGET_REPLACE_MODULES = [ + "BasicAVTransformerBlock", +] + +# LoRA target presets for different training modes +# These patterns match layers inside BasicAVTransformerBlock. +# +# Available modules (from official LTX-2 docs): +# +# VIDEO MODULES: +# - attn1.to_k, attn1.to_q, attn1.to_v, attn1.to_out.0 (video self-attention) +# - attn2.to_k, attn2.to_q, attn2.to_v, attn2.to_out.0 (video cross-attention to text) +# - ff.net.0.proj, ff.net.2 (video feed-forward) +# +# AUDIO MODULES: +# - audio_attn1.to_k, audio_attn1.to_q, etc. (audio self-attention) +# - audio_attn2.to_k, audio_attn2.to_q, etc. (audio cross-attention to text) +# - audio_ff.net.0.proj, audio_ff.net.2 (audio feed-forward) +# +# CROSS-MODAL MODULES: +# - audio_to_video_attn.to_k, etc. (audio-to-video cross-attention) +# - video_to_audio_attn.to_k, etc. (video-to-audio cross-attention) +# +# Using short patterns like "to_k" matches ALL attention modules across video, audio, +# and cross-modal branches. This is the recommended approach for audio-video training. + +# t2v: Text-to-video (attention only) +# Official LTX-2 trainer default. Trains all attention projections (Q, K, V, Out) +# across video, audio, and cross-modal attention blocks. +LTX2_INCLUDE_PATTERNS_T2V = [ + r".*\.to_k$", + r".*\.to_q$", + r".*\.to_v$", + r".*\.to_out\.0$", +] + +# v2v: Video-to-video / IC-LoRA (attention + feed-forward) +# Recommended for IC-LoRA and reference-based generation. Adds FFN layers +# for more expressive capacity when learning from reference videos. +LTX2_INCLUDE_PATTERNS_V2V = [ + r".*\.to_k$", + r".*\.to_q$", + r".*\.to_v$", + r".*\.to_out\.0$", + r".*\.ff\.net\.0\.proj$", + r".*\.ff\.net\.2$", + r".*\.audio_ff\.net\.0\.proj$", + r".*\.audio_ff\.net\.2$", +] + +# audio: Audio-only LoRA (audio attention/FFN + audio-side cross-modal) +# Targets audio self/cross-attn, audio FFN, and video_to_audio_attn (audio queries video). +# Excludes audio_to_video_attn to avoid altering the video branch. +LTX2_INCLUDE_PATTERNS_AUDIO = [ + r".*\.audio_attn1\.to_k$", + r".*\.audio_attn1\.to_q$", + r".*\.audio_attn1\.to_v$", + r".*\.audio_attn1\.to_out\.0$", + r".*\.audio_attn2\.to_k$", + r".*\.audio_attn2\.to_q$", + r".*\.audio_attn2\.to_v$", + r".*\.audio_attn2\.to_out\.0$", + r".*\.audio_ff\.net\.0\.proj$", + r".*\.audio_ff\.net\.2$", + r".*\.video_to_audio_attn\.to_k$", + r".*\.video_to_audio_attn\.to_q$", + r".*\.video_to_audio_attn\.to_v$", + r".*\.video_to_audio_attn\.to_out\.0$", +] + +# audio_ref_only_ic: ID-LoRA-style audio-reference IC preset. +# Targets audio self/cross-attn, audio FFN, and BOTH AV cross-modal directions. +# Mirrors ID-LoRA target_modules: +# - audio_attn1 / audio_attn2 +# - audio_ff +# - audio_to_video_attn / video_to_audio_attn +LTX2_INCLUDE_PATTERNS_AUDIO_REF_ONLY_IC = [ + r".*\.audio_attn1\.to_k$", + r".*\.audio_attn1\.to_q$", + r".*\.audio_attn1\.to_v$", + r".*\.audio_attn1\.to_out\.0$", + r".*\.audio_attn2\.to_k$", + r".*\.audio_attn2\.to_q$", + r".*\.audio_attn2\.to_v$", + r".*\.audio_attn2\.to_out\.0$", + r".*\.audio_ff\.net\.0\.proj$", + r".*\.audio_ff\.net\.2$", + r".*\.audio_to_video_attn\.to_k$", + r".*\.audio_to_video_attn\.to_q$", + r".*\.audio_to_video_attn\.to_v$", + r".*\.audio_to_video_attn\.to_out\.0$", + r".*\.video_to_audio_attn\.to_k$", + r".*\.video_to_audio_attn\.to_q$", + r".*\.video_to_audio_attn\.to_v$", + r".*\.video_to_audio_attn\.to_out\.0$", +] + +# full: All linear layers in transformer blocks +# Maximum expressiveness, but larger LoRA file and more VRAM usage. +LTX2_INCLUDE_PATTERNS_FULL = None # None means no filtering, all Linear layers matched + +# Mapping from preset name to include patterns +LTX2_LORA_TARGET_PRESETS = { + "t2v": LTX2_INCLUDE_PATTERNS_T2V, + "v2v": LTX2_INCLUDE_PATTERNS_V2V, + "audio": LTX2_INCLUDE_PATTERNS_AUDIO, + "audio_ref_only_ic": LTX2_INCLUDE_PATTERNS_AUDIO_REF_ONLY_IC, + "full": LTX2_INCLUDE_PATTERNS_FULL, +} + +# Default preset (for backwards compatibility) +LTX2_DEFAULT_INCLUDE_PATTERNS = LTX2_INCLUDE_PATTERNS_T2V + + +def _build_exclude_patterns(raw_patterns: Optional[str], audio_video: bool = False) -> List[str]: # noqa: ARG001 + """Build exclude patterns list, including connector exclusions.""" + patterns: List[str] = [ + r".*text_embedding_projection\.aggregate_embed.*", + r".*text_embedding_projection\.video_aggregate_embed.*", + r".*text_embedding_projection\.audio_aggregate_embed.*", + r".*embeddings_connector\..*", + r".*audio_embeddings_connector\..*", + ] + if raw_patterns is None: + return patterns + user_patterns = ast.literal_eval(raw_patterns) + if not isinstance(user_patterns, list): + raise ValueError("exclude_patterns must evaluate to a list") + patterns.extend(user_patterns) + return patterns + + +def _get_include_patterns_for_preset(preset: Optional[str]) -> Optional[List[str]]: + """Get include patterns for a given preset name.""" + if preset is None: + return LTX2_DEFAULT_INCLUDE_PATTERNS + if preset not in LTX2_LORA_TARGET_PRESETS: + raise ValueError( + f"Unknown lora_target_preset: {preset!r}. " + f"Valid presets: {list(LTX2_LORA_TARGET_PRESETS.keys())}" + ) + return LTX2_LORA_TARGET_PRESETS[preset] + + +def compute_loftq_from_state_dict( + state_dict: dict, + loftq_config: dict, + network_dim: int, + target_layer_keys: Optional[List[str]] = None, + exclude_layer_keys: Optional[List[str]] = None, +) -> Dict[str, tuple]: + """Pre-compute LoftQ (lora_A, lora_B) from full-precision weights in a state dict. + + Must be called BEFORE NF4 quantization, while weights are still full-precision. + + Returns a dict mapping ``lora_unet_`` → ``(lora_A, lora_B)``. + """ + from tqdm import tqdm + from musubi_tuner.modules.loftq_init import loftq_initialize + from musubi_tuner.modules.nf4_optimization_utils import quantize_nf4_block, dequantize_nf4_block + + num_iterations = loftq_config.get("num_iterations", 1) + block_size = loftq_config.get("block_size", 64) + device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") + + # Find target weight keys (same filtering as NF4 quantization) + target_keys = [] + for key in state_dict: + if not key.endswith(".weight"): + continue + is_target = target_layer_keys is None or any(p in key for p in target_layer_keys) + is_excluded = exclude_layer_keys is not None and any(p in key for p in exclude_layer_keys) + if is_target and not is_excluded: + w = state_dict[key] + if isinstance(w, torch.Tensor) and w.ndim == 2 and w.shape[1] % block_size == 0: + target_keys.append(key) + + loftq_data: Dict[str, tuple] = {} + for key in tqdm(target_keys, desc="LoftQ SVD init"): + weight = state_dict[key] + # Build lora_name matching the convention in lora.py's create_modules + module_path = key.rsplit(".weight", 1)[0] + lora_name = f"lora_unet_{module_path}".replace(".", "_") + try: + lora_A, lora_B = loftq_initialize( + weight, + quantize_fn=quantize_nf4_block, + dequantize_fn=dequantize_nf4_block, + lora_rank=network_dim, + block_size=block_size, + num_iterations=num_iterations, + device=device, + ) + loftq_data[lora_name] = (lora_A.cpu(), lora_B.cpu()) + except Exception as e: + logger.warning("LoftQ init failed for %s: %s", module_path, e) + continue + + logger.info("LoftQ initialization computed for %d modules", len(loftq_data)) + return loftq_data + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + audio_video = kwargs.pop("audio_video", False) + if not audio_video and unet is not None: + audio_video = unet.__class__.__name__ == "LTXAVModel" or hasattr(unet, "audio_patchify_proj") + + kwargs["exclude_patterns"] = _build_exclude_patterns(kwargs.get("exclude_patterns"), audio_video=audio_video) + + # Handle lora_target_preset: use preset patterns unless include_patterns is explicitly set + lora_target_preset = kwargs.pop("lora_target_preset", None) + if kwargs.get("include_patterns") is None: + preset_patterns = _get_include_patterns_for_preset(lora_target_preset) + kwargs["include_patterns"] = preset_patterns + if lora_target_preset is not None: + logger.info(f"Using LoRA target preset '{lora_target_preset}' with patterns: {preset_patterns}") + else: + if lora_target_preset is not None: + logger.warning( + f"Both lora_target_preset='{lora_target_preset}' and include_patterns are set. " + "Using explicit include_patterns, ignoring preset." + ) + + # Handle LoftQ: loftq_data is pre-computed from full-precision weights + # before NF4 quantization (passed via kwargs from the training script) + kwargs.pop("loftq_config", None) # consumed upstream, not needed here + loftq_data = kwargs.pop("loftq_data", None) + if loftq_data is not None: + module_kwargs = kwargs.get("module_kwargs", None) or {} + module_kwargs["loftq_data"] = loftq_data + kwargs["module_kwargs"] = module_kwargs + + net = lora.create_network( + LTX2_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + return _patch_lora_load_state_dict_for_audio(net) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora.LoRANetwork: + audio_video = kwargs.pop("audio_video", False) + if not audio_video: + audio_video = any("audio_" in k for k in weights_sd.keys()) + if not audio_video and unet is not None: + audio_video = unet.__class__.__name__ == "LTXAVModel" or hasattr(unet, "audio_patchify_proj") + + kwargs["exclude_patterns"] = _build_exclude_patterns(kwargs.get("exclude_patterns"), audio_video=audio_video) + + net = lora.create_network_from_weights( + LTX2_TARGET_REPLACE_MODULES, + multiplier, + weights_sd, + text_encoders, + unet, + for_inference, + **kwargs, + ) + return _patch_lora_load_state_dict_for_audio(net) diff --git a/src/musubi_tuner/networks/lora_qwen_image.py b/src/musubi_tuner/networks/lora_qwen_image.py new file mode 100644 index 0000000000000000000000000000000000000000..a14c0a42234a2e4f97ee2a1297086e60bb8609b1 --- /dev/null +++ b/src/musubi_tuner/networks/lora_qwen_image.py @@ -0,0 +1,65 @@ +# LoRA module for Qwen-Image + +import ast +from typing import Dict, List, Optional +import torch +import torch.nn as nn + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +import musubi_tuner.networks.lora as lora + + +QWEN_IMAGE_TARGET_REPLACE_MODULES = ["QwenImageTransformerBlock"] + + +def create_arch_network( + multiplier: float, + network_dim: Optional[int], + network_alpha: Optional[float], + vae: nn.Module, + text_encoders: List[nn.Module], + unet: nn.Module, + neuron_dropout: Optional[float] = None, + **kwargs, +): + # add default exclude patterns + exclude_patterns = kwargs.get("exclude_patterns", None) + if exclude_patterns is None: + exclude_patterns = [] + else: + exclude_patterns = ast.literal_eval(exclude_patterns) + + # exclude if '_mod_' in the name of the module (modulation) + exclude_patterns.append(r".*(_mod_).*") + + kwargs["exclude_patterns"] = exclude_patterns + + return lora.create_network( + QWEN_IMAGE_TARGET_REPLACE_MODULES, + "lora_unet", + multiplier, + network_dim, + network_alpha, + vae, + text_encoders, + unet, + neuron_dropout=neuron_dropout, + **kwargs, + ) + + +def create_arch_network_from_weights( + multiplier: float, + weights_sd: Dict[str, torch.Tensor], + text_encoders: Optional[List[nn.Module]] = None, + unet: Optional[nn.Module] = None, + for_inference: bool = False, + **kwargs, +) -> lora.LoRANetwork: + return lora.create_network_from_weights( + QWEN_IMAGE_TARGET_REPLACE_MODULES, multiplier, weights_sd, text_encoders, unet, for_inference, **kwargs + ) diff --git a/src/musubi_tuner/networks/lycoris_extensions.py b/src/musubi_tuner/networks/lycoris_extensions.py new file mode 100644 index 0000000000000000000000000000000000000000..9304bbb7f986b6475586f6fde987cbb0ec45aece --- /dev/null +++ b/src/musubi_tuner/networks/lycoris_extensions.py @@ -0,0 +1,232 @@ +"""LyCORIS extensions and utilities for musubi-tuner. + +Provides enhancements to LyCORIS: +- Special initialization methods +- Integration helpers +""" + +import logging +import torch +import torch.nn as nn +from typing import Dict, Any, Optional + +logger = logging.getLogger(__name__) + + +def init_lokr_network_with_perturbed_normal(network, scale: float = 1e-3) -> None: + """Initialize LoKR network with perturbed normal distribution. + + This helps training stability by starting with small perturbations + rather than zeros. + + Args: + network: LyCORIS network instance + scale: Standard deviation for perturbation (default: 1e-3) + """ + if not hasattr(network, 'loras'): + logger.warning("Network doesn't have 'loras' attribute, skipping LoKR init") + return + + logger.info(f"Initializing LoKR network with perturbed normal (scale={scale})") + + initialized_count = 0 + with torch.no_grad(): + for lora_module in network.loras: + # LoKR modules have lokr_w1 and lokr_w2 + if hasattr(lora_module, 'lokr_w1'): + # Initialize w1 to identity (ones) + if isinstance(lora_module.lokr_w1, nn.Parameter): + lora_module.lokr_w1.fill_(1.0) + initialized_count += 1 + elif hasattr(lora_module, 'lokr_w1_a') and hasattr(lora_module, 'lokr_w1_b'): + # Factorized form + lora_module.lokr_w1_a.fill_(1.0) + lora_module.lokr_w1_b.fill_(1.0) + initialized_count += 1 + + if hasattr(lora_module, 'lokr_w2'): + # Initialize w2 with small normal perturbation + if isinstance(lora_module.lokr_w2, nn.Parameter): + nn.init.normal_(lora_module.lokr_w2, mean=0.0, std=scale) + initialized_count += 1 + elif hasattr(lora_module, 'lokr_w2_a') and hasattr(lora_module, 'lokr_w2_b'): + # Factorized form + nn.init.normal_(lora_module.lokr_w2_a, mean=0.0, std=scale) + nn.init.normal_(lora_module.lokr_w2_b, mean=0.0, std=scale) + initialized_count += 1 + + logger.info(f"Initialized {initialized_count} LoKR module(s)") + + +def build_network_kwargs_from_config( + config: Dict[str, Any], + base_dim: Optional[int] = None, + base_alpha: Optional[int] = None, +) -> Dict[str, Any]: + """Build network kwargs from configuration. + + Converts config format to kwargs that can be passed to + network.create_arch_network(). + + Args: + config: Network configuration dict + base_dim: Base network dimension (overrides config) + base_alpha: Base network alpha (overrides config) + + Returns: + Network kwargs dict + """ + kwargs = {} + + # Base algorithm + if "base_algo" in config: + kwargs["algo"] = config["base_algo"] + + # Base factor (for LoKR/LoHA) + if "base_factor" in config: + kwargs["factor"] = config["base_factor"] + + # Dimension/alpha can override config + if base_dim is not None: + kwargs["dim"] = base_dim + elif "dim" in config: + kwargs["dim"] = config["dim"] + + if base_alpha is not None: + kwargs["alpha"] = base_alpha + elif "alpha" in config: + kwargs["alpha"] = config["alpha"] + + return kwargs + + +def config_to_lycoris_preset(config: Dict[str, Any]) -> Dict[str, Any]: + """Convert config to LyCORIS apply_preset format. + + Args: + config: Network configuration dict + + Returns: + LyCORIS preset dict for apply_preset() + """ + preset = {} + + if "modules" in config and config["modules"]: + # Build module_algo_map + module_algo_map = {} + name_algo_map = {} + + for module_name, module_config in config["modules"].items(): + # Wildcard patterns go to name_algo_map + if "*" in module_name: + name_algo_map[module_name] = module_config + else: + module_algo_map[module_name] = module_config + + if module_algo_map: + preset["module_algo_map"] = module_algo_map + if name_algo_map: + preset["name_algo_map"] = name_algo_map + + # Collect all target modules + target_modules = [m for m in config["modules"].keys() if "*" not in m] + if target_modules: + # lycoris.kohya expects this key name in apply_preset. + preset["unet_target_module"] = target_modules + if name_algo_map: + # Wildcard patterns should be interpreted with fnmatch, not regex. + preset["use_fnmatch"] = True + + return preset + + +def get_config_init_params(config: Dict[str, Any]) -> Dict[str, Any]: + """Extract initialization parameters from config. + + Args: + config: Network configuration dict + + Returns: + Dict of initialization parameters + """ + return config.get("init", {}) + + +def log_network_config(config: Dict[str, Any], logger_instance: Optional[logging.Logger] = None) -> None: + """Log network configuration for debugging. + + Args: + config: Network configuration dict + logger_instance: Optional logger instance + """ + log = logger_instance or logger + + log.info("=== Network Configuration ===") + + if "description" in config: + log.info(f"Description: {config['description']}") + + if "base_algo" in config: + log.info(f"Base algorithm: {config['base_algo']}") + + if "base_factor" in config: + log.info(f"Base factor: {config['base_factor']}") + + if "modules" in config and config["modules"]: + log.info("Module-specific settings:") + for module_name, module_config in config["modules"].items(): + log.info(f" {module_name}: {module_config}") + + if "init" in config and config["init"]: + log.info("Initialization settings:") + for param, value in config["init"].items(): + log.info(f" {param}: {value}") + + log.info("=" * 30) + + +def validate_lycoris_available() -> bool: + """Check if LyCORIS is installed and available. + + Returns: + True if LyCORIS is available, False otherwise + """ + try: + import lycoris + return True + except ImportError: + return False + + +def get_lycoris_info() -> Dict[str, Any]: + """Get information about installed LyCORIS. + + Returns: + Dict with version and available algorithms + """ + try: + import lycoris + + info = { + "installed": True, + "version": getattr(lycoris, "__version__", "unknown"), + } + + # Try to get available algorithms + try: + from lycoris import list_algorithms + info["algorithms"] = list_algorithms() + except (ImportError, AttributeError): + info["algorithms"] = ["lora", "loha", "lokr", "locon", "ia3"] + + return info + + except ImportError: + return { + "installed": False, + "version": None, + "algorithms": [] + } + + + diff --git a/src/musubi_tuner/networks/network_arch.py b/src/musubi_tuner/networks/network_arch.py new file mode 100644 index 0000000000000000000000000000000000000000..9178f5969fdc8c07f5674c8447f480a09b23b93f --- /dev/null +++ b/src/musubi_tuner/networks/network_arch.py @@ -0,0 +1,72 @@ +"""Architecture detection and configuration for network modules (LoHa, LoKr, etc.).""" + +import logging + +logger = logging.getLogger(__name__) + + +def detect_arch_config(unet): + """Detect architecture from model structure. + + Returns: (target_replace_modules, default_exclude_patterns) + """ + module_class_names = set() + for module in unet.modules(): + module_class_names.add(type(module).__name__) + + # Order matters for disambiguation + if "WanAttentionBlock" in module_class_names: + from .lora_wan import WAN_TARGET_REPLACE_MODULES + + return WAN_TARGET_REPLACE_MODULES, [r".*(patch_embedding|text_embedding|time_embedding|time_projection|norm|head).*"] + + if "QwenImageTransformerBlock" in module_class_names: + from .lora_qwen_image import QWEN_IMAGE_TARGET_REPLACE_MODULES + + return QWEN_IMAGE_TARGET_REPLACE_MODULES, [r".*(_mod_).*"] + + if "ZImageTransformerBlock" in module_class_names: + from .lora_zimage import ZIMAGE_TARGET_REPLACE_MODULES + + return ZIMAGE_TARGET_REPLACE_MODULES, [r".*(_modulation|_refiner).*"] + + if "HunyuanVideoTransformerBlock" in module_class_names: + from .lora_framepack import FRAMEPACK_TARGET_REPLACE_MODULES + + return FRAMEPACK_TARGET_REPLACE_MODULES, [r".*(norm).*"] + + if "LTX2Wrapper" in module_class_names or "LTXAVModel" in module_class_names or "LTXVideoOnlyModel" in module_class_names: + from .lora_ltx2 import LTX2_TARGET_REPLACE_MODULES + + return LTX2_TARGET_REPLACE_MODULES, [ + r".*text_embedding_projection\.aggregate_embed.*", + r".*text_embedding_projection\.video_aggregate_embed.*", + r".*text_embedding_projection\.audio_aggregate_embed.*", + r".*embeddings_connector\..*", + r".*audio_embeddings_connector\..*", + ] + + # Kandinsky5 is not supported in auto-detection (uses include_patterns, requires special handling) + + if "DoubleStreamBlock" in module_class_names: + # FLUX Kontext and FLUX 2 share same target/exclude config + from .lora_flux import FLUX_KONTEXT_TARGET_REPLACE_MODULES + + return FLUX_KONTEXT_TARGET_REPLACE_MODULES, [ + r".*(img_mod\.lin|txt_mod\.lin|modulation\.lin).*", + r".*(norm).*", + ] + + if "MMSingleStreamBlock" in module_class_names: + # HunyuanVideo (has both MMDoubleStreamBlock and MMSingleStreamBlock) + from .lora import HUNYUAN_TARGET_REPLACE_MODULES + + return HUNYUAN_TARGET_REPLACE_MODULES, [r".*(img_mod|txt_mod|modulation).*"] + + if "MMDoubleStreamBlock" in module_class_names: + # HunyuanVideo 1.5 (only MMDoubleStreamBlock, no MMSingleStreamBlock) + from .lora_hv_1_5 import HV_1_5_IMAGE_TARGET_REPLACE_MODULES + + return HV_1_5_IMAGE_TARGET_REPLACE_MODULES, [r".*(_in).*"] + + raise ValueError(f"Cannot auto-detect architecture. Module classes found: {sorted(module_class_names)}") diff --git a/src/musubi_tuner/networks/network_config.py b/src/musubi_tuner/networks/network_config.py new file mode 100644 index 0000000000000000000000000000000000000000..cda2d605c30c5ac0288b4518744611eb49eaca54 --- /dev/null +++ b/src/musubi_tuner/networks/network_config.py @@ -0,0 +1,314 @@ +"""Network configuration parser and auto-configuration. + +Handles: +- TOML config file parsing (musubi-native format) +- Enhanced --network_args parsing +- Auto-configuration based on model/mode +""" + +from typing import Dict, Any, Optional, List +import os +import logging + +logger = logging.getLogger(__name__) + + +def parse_toml_config(config_path: str) -> Dict[str, Any]: + """Parse network configuration from TOML file. + + Format: + [network] + base_algo = "lokr" + base_factor = 16 + + [network.modules.Attention] + algo = "lokr" + factor = 16 + + [network.init] + lokr_norm = 1e-3 + + Args: + config_path: Path to TOML config file + + Returns: + Configuration dict + """ + try: + import tomli as tomllib + except ImportError: + try: + import tomllib # Python 3.11+ + except ImportError: + raise ImportError( + "TOML support requires 'tomli' package. Install with: pip install tomli" + ) + + if not os.path.isfile(config_path): + raise FileNotFoundError(f"Network config not found: {config_path}") + + with open(config_path, "rb") as f: + data = tomllib.load(f) + + if "network" not in data: + raise ValueError(f"TOML config must have [network] section: {config_path}") + + config = data["network"] + + # Convert TOML structure to recipe format + recipe = { + "description": config.get("description", "TOML config"), + "base_algo": config.get("base_algo", "lora"), + "modules": {}, + "init": {} + } + + if "base_factor" in config: + recipe["base_factor"] = config["base_factor"] + + # Extract module configs + if "modules" in config: + recipe["modules"] = config["modules"] + + # Extract init params + if "init" in config: + recipe["init"] = config["init"] + + return recipe + + +def parse_network_args_enhanced(network_args: Optional[List[str]]) -> Dict[str, Any]: + """Parse network args with enhanced support for nested keys. + + Supports: + - Simple: "algo=lokr", "factor=16" + - Nested: "modules.Attention.factor=16" + - Init: "init.lokr_norm=1e-3" + + Args: + network_args: List of "key=value" strings + + Returns: + Parsed configuration dict + """ + if not network_args: + return {} + + config = {} + + for arg in network_args: + if "=" not in arg: + logger.warning(f"Ignoring invalid network arg (no '='): {arg}") + continue + + key, value = arg.split("=", 1) + key = key.strip() + value = value.strip() + + # Try to parse value as appropriate type + parsed_value = _parse_value(value) + + # Handle nested keys + if "." in key: + config[key] = parsed_value + else: + # Simple key-value for backward compatibility + config[key] = parsed_value + + return config + + +def _parse_value(value: str) -> Any: + """Parse string value to appropriate Python type. + + Args: + value: String value + + Returns: + Parsed value (int, float, bool, or str) + """ + # Try int + try: + return int(value) + except ValueError: + pass + + # Try float + try: + return float(value) + except ValueError: + pass + + # Try bool + if value.lower() in ("true", "yes", "1"): + return True + if value.lower() in ("false", "no", "0"): + return False + + # Return as string + return value + + +def auto_configure_network( + ltx2_checkpoint: str, + ltx2_mode: str, + network_dim: Optional[int] = None, +) -> Dict[str, Any]: + """Auto-configure network based on model and training mode. + + Detects: + - Model caption_channels (LTXAV=3840, LTXV=1920) + - Training mode (video/av/audio) + - Optimal factor based on model size + + Args: + ltx2_checkpoint: Path to LTX-2 checkpoint + ltx2_mode: Training mode (v/av/audio) + network_dim: Base network dimension (optional) + + Returns: + Auto-configuration dict + """ + config = {"modules": {}, "init": {}} + + # Detect caption_channels + caption_channels = _detect_caption_channels(ltx2_checkpoint) + + if caption_channels is not None: + logger.info(f"Auto-config: Detected caption_channels={caption_channels}") + + # Auto-factor based on model size + if caption_channels == 3840: # LTXAV + config["base_factor"] = 16 + logger.info("Auto-config: LTXAV model detected, using factor=16") + elif caption_channels == 1920: # LTXV + config["base_factor"] = 12 + logger.info("Auto-config: LTXV model detected, using factor=12") + + # Audio mode adjustments + if ltx2_mode in ["av", "audio"]: + logger.info("Auto-config: Audio mode detected, adding higher rank for audio modules") + dim = network_dim or 64 + config["modules"]["*audio*"] = { + "algo": "lora", "dim": dim, "alpha": dim // 2 + } + + # Clean up empty dicts so merge_configs skips them + if not config["modules"]: + del config["modules"] + if not config["init"]: + del config["init"] + + return config + + +def _detect_caption_channels(checkpoint_path: str) -> Optional[int]: + """Detect caption_channels from LTX-2 checkpoint. + + Args: + checkpoint_path: Path to checkpoint + + Returns: + caption_channels value or None if detection fails + """ + try: + from musubi_tuner.utils.safetensors_utils import MemoryEfficientSafeOpen + + with MemoryEfficientSafeOpen(checkpoint_path) as handle: + # Look for caption_projection.linear_1.weight + key = "caption_projection.linear_1.weight" + if key in handle.keys(): + meta = handle.header.get(key) + if isinstance(meta, dict) and "shape" in meta: + shape = meta["shape"] + if len(shape) >= 2: + # in_features is shape[1] for linear layers + return shape[1] + + logger.warning("Could not detect caption_channels from checkpoint") + return None + + except Exception as e: + logger.warning(f"Failed to detect caption_channels: {e}") + return None + + +def merge_configs(*configs: Dict[str, Any]) -> Dict[str, Any]: + """Merge multiple configuration dicts (later ones override earlier). + + Args: + *configs: Configuration dicts to merge + + Returns: + Merged configuration + """ + import copy + + result = {} + + for config in configs: + if not config: + continue + + result = _deep_merge(result, copy.deepcopy(config)) + + return result + + +def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]: + """Deep merge two dicts. + + Args: + base: Base dict + override: Override dict + + Returns: + Merged dict + """ + result = base.copy() + + for key, value in override.items(): + if key in result and isinstance(result[key], dict) and isinstance(value, dict): + result[key] = _deep_merge(result[key], value) + else: + result[key] = value + + return result + + +def validate_network_config(config: Dict[str, Any]) -> None: + """Validate network configuration. + + Args: + config: Network configuration dict + + Raises: + ValueError: If configuration is invalid + """ + valid_algos = ["lora", "loha", "lokr", "locon", "ia3", "full"] + + # Check base_algo + if "base_algo" in config: + if config["base_algo"] not in valid_algos: + raise ValueError( + f"Invalid base_algo: {config['base_algo']}. " + f"Valid options: {', '.join(valid_algos)}" + ) + + # Check module configs + if "modules" in config: + for module_name, module_config in config["modules"].items(): + if "algo" in module_config: + if module_config["algo"] not in valid_algos: + raise ValueError( + f"Invalid algo for {module_name}: {module_config['algo']}" + ) + + # Validate algo-specific params + if module_config.get("algo") == "lora": + if "dim" in module_config and module_config["dim"] <= 0: + raise ValueError(f"Invalid dim for {module_name}: must be > 0") + + elif module_config.get("algo") in ["lokr", "loha"]: + if "factor" in module_config and module_config["factor"] <= 0: + raise ValueError(f"Invalid factor for {module_name}: must be > 0") diff --git a/src/musubi_tuner/networks/optimizer_params_compat.py b/src/musubi_tuner/networks/optimizer_params_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..3c51bc7bb519cb507bd2cfe90fbe991431d3ad10 --- /dev/null +++ b/src/musubi_tuner/networks/optimizer_params_compat.py @@ -0,0 +1,147 @@ +import argparse +import inspect +import logging +from typing import Any, Optional + +import torch + + +def _filter_supported_kwargs(fn: Any, kwargs: dict[str, Any]) -> tuple[dict[str, Any], list[str]]: + try: + signature = inspect.signature(fn) + except (TypeError, ValueError): + return kwargs, [] + + if any(param.kind == inspect.Parameter.VAR_KEYWORD for param in signature.parameters.values()): + return kwargs, [] + + filtered: dict[str, Any] = {} + skipped: list[str] = [] + for key, value in kwargs.items(): + param = signature.parameters.get(key) + if param is None or param.kind == inspect.Parameter.POSITIONAL_ONLY: + if value is not None: + skipped.append(key) + continue + filtered[key] = value + + return filtered, skipped + + +def _normalize_optimizer_param_groups(trainable_params: Any) -> tuple[list[Any], int]: + if trainable_params is None: + return [], 0 + + if isinstance(trainable_params, torch.nn.Parameter): + groups: list[Any] = [trainable_params] + elif isinstance(trainable_params, dict): + groups = [trainable_params] + elif isinstance(trainable_params, (list, tuple)): + groups = list(trainable_params) + else: + try: + groups = list(trainable_params) + except TypeError: + groups = [trainable_params] + + normalized: list[Any] = [] + total_params = 0 + + for group in groups: + if isinstance(group, dict): + group_copy = dict(group) + params_obj = group_copy.get("params", []) + if isinstance(params_obj, torch.nn.Parameter): + params = [params_obj] + else: + try: + params = list(params_obj) + except TypeError: + params = [params_obj] + + params = [param for param in params if isinstance(param, torch.nn.Parameter)] + if len(params) == 0: + continue + + group_copy["params"] = params + normalized.append(group_copy) + total_params += len(params) + continue + + if isinstance(group, torch.nn.Parameter): + normalized.append(group) + total_params += 1 + + return normalized, total_params + + +def _collect_fallback_trainable_params(network: Any) -> tuple[list[Any], int, Optional[str]]: + if hasattr(network, "requires_grad_"): + try: + network.requires_grad_(True) + except Exception: + pass + + for source in ("get_trainable_params", "parameters"): + getter = getattr(network, source, None) + if not callable(getter): + continue + try: + candidate_params = getter() + except TypeError: + continue + + normalized, count = _normalize_optimizer_param_groups(candidate_params) + if count > 0: + return normalized, count, source + + return [], 0, None + + +def prepare_optimizer_params_compat( + network: Any, + args: argparse.Namespace, + logger: logging.Logger, +) -> tuple[list[Any], Optional[list[str]]]: + prepare_fn = getattr(network, "prepare_optimizer_params", None) + if not callable(prepare_fn): + raise AttributeError(f"{network.__class__.__name__} does not implement prepare_optimizer_params") + + requested_kwargs = { + "unet_lr": args.learning_rate, + "audio_lr": getattr(args, "audio_lr", None), + "lr_args": getattr(args, "lr_args", None), + } + prepare_kwargs, skipped_kwargs = _filter_supported_kwargs(prepare_fn, requested_kwargs) + if skipped_kwargs: + logger.info( + "Skipping unsupported prepare_optimizer_params kwargs for %s: %s", + network.__class__.__name__, + ", ".join(skipped_kwargs), + ) + + prepared = prepare_fn(**prepare_kwargs) + if isinstance(prepared, tuple): + trainable_params = prepared[0] if len(prepared) > 0 else None + lr_descriptions = prepared[1] if len(prepared) > 1 else None + else: + trainable_params, lr_descriptions = prepared, None + + normalized_params, param_count = _normalize_optimizer_param_groups(trainable_params) + if param_count > 0: + return normalized_params, lr_descriptions + + fallback_params, fallback_count, fallback_source = _collect_fallback_trainable_params(network) + if fallback_count > 0: + logger.warning( + "prepare_optimizer_params for %s returned no params; falling back to network.%s() with %d params.", + network.__class__.__name__, + fallback_source, + fallback_count, + ) + return fallback_params, lr_descriptions + + raise ValueError( + "No trainable parameters were found for the network. " + "Check LoRA/LyCORIS target selection and network configuration." + ) diff --git a/src/musubi_tuner/optimizers/automagic.py b/src/musubi_tuner/optimizers/automagic.py new file mode 100644 index 0000000000000000000000000000000000000000..c32fdd2dbede7142579607c19770c9f72ae75b6b --- /dev/null +++ b/src/musubi_tuner/optimizers/automagic.py @@ -0,0 +1,475 @@ +# Copied from diffusion-pipe, originally from AI Toolkit. +# Kahan summation for bfloat16 parameters added by diffusion-pipe. + +# MIT License + +# Copyright (c) 2024 Ostris, LLC + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +from typing import List +import torch +from musubi_tuner.optimizers.optimizer_utils import Auto8bitTensor, copy_stochastic +import random + +try: + from optimum.quanto import QBytesTensor + HAS_QBYTES = True +except ImportError: + HAS_QBYTES = False + + +class Automagic(torch.optim.Optimizer): + def __init__( + self, + params, + lr=1e-6, # lr is start lr + min_lr=1e-7, + max_lr=1e-3, + lr_bump=1e-6, # amount to bump the lr when adjusting + eps=(1e-30, 1e-3), + clip_threshold=1.0, + beta2=0.999, + weight_decay=0.0, + do_paramiter_swapping=False, + paramiter_swapping_factor=0.1, + ): + self.lr = lr + if self.lr > 1e-3: + print(f"Warning! Start lr is very high: {self.lr}. Forcing to 1e-6. this does not work like prodigy") + self.lr = 1e-6 + self.min_lr = min_lr + self.max_lr = max_lr + self.lr_bump = lr_bump + + defaults = { + "lr": lr, + "eps": eps, + "clip_threshold": clip_threshold, + "beta2": beta2, + "weight_decay": weight_decay, + } + super().__init__(params, defaults) + + self.base_lrs: List[float] = [ + lr for group in self.param_groups + ] + + self.is_stochastic_rounding_accumulation = False + + self.do_paramiter_swapping = do_paramiter_swapping + self.paramiter_swapping_factor = paramiter_swapping_factor + self._total_paramiter_size = 0 + # count total paramiters + for group in self.param_groups: + for param in group['params']: + self._total_paramiter_size += torch.numel(param) + # pretty print total paramiters with comma seperation + print(f"Total training paramiters: {self._total_paramiter_size:,}") + + # needs to be enabled to count paramiters + if self.do_paramiter_swapping: + self.enable_paramiter_swapping(self.paramiter_swapping_factor) + + def enable_paramiter_swapping(self, paramiter_swapping_factor=0.1): + self.do_paramiter_swapping = True + self.paramiter_swapping_factor = paramiter_swapping_factor + # call it an initial time + self.swap_paramiters() + + def swap_paramiters(self): + all_params = [] + # deactivate all paramiters + for group in self.param_groups: + for param in group['params']: + param.requires_grad_(False) + # remove any grad + param.grad = None + all_params.append(param) + # shuffle all paramiters + random.shuffle(all_params) + + # keep activating paramiters until we are going to go over the target paramiters + target_paramiters = int( + self._total_paramiter_size * self.paramiter_swapping_factor) + total_paramiters = 0 + for param in all_params: + total_paramiters += torch.numel(param) + if total_paramiters >= target_paramiters: + break + else: + param.requires_grad_(True) + + @staticmethod + def _get_lr(param_group, param_state): + if 'avg_lr' in param_state: + lr = param_state["avg_lr"] + else: + lr = 0.0 + return lr + + def _get_group_lr(self, group): + group_lrs = [] + for p in group["params"]: + group_lrs.append(self._get_lr(group, self.state[p])) + # return avg + if len(group_lrs) == 0: + return self.lr + return sum(group_lrs) / len(group_lrs) + + @staticmethod + def _rms(tensor): + return tensor.norm(2) / (tensor.numel() ** 0.5) + + @staticmethod + def _approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col): + r_factor = (exp_avg_sq_row / exp_avg_sq_row.mean(dim=- + 1, keepdim=True)).rsqrt_().unsqueeze(-1) + c_factor = exp_avg_sq_col.unsqueeze(-2).rsqrt() + return torch.mul(r_factor, c_factor) + + def step_hook(self): + if not self.is_stochastic_rounding_accumulation: + return + # copy over stochastically rounded grads + for group in self.param_groups: + for param in group['params']: + if param.requires_grad and hasattr(param, "_accum_grad"): + param.grad = param._accum_grad + del param._accum_grad + + # automagic manages its own lr + def get_learning_rates(self): + + lrs = [ + self._get_group_lr(group) + for group in self.param_groups + ] + if len(lrs) == 0: + lrs = self.base_lrs # if called before stepping + return lrs + + def get_avg_learning_rate(self): + lrs = self.get_learning_rates() + return sum(lrs) / len(lrs) + + def get_lr_tensor(self): + """Return per-parameter avg learning rates as a 1D tensor for histogram logging.""" + lrs = [] + for group in self.param_groups: + for p in group["params"]: + state = self.state.get(p, {}) + if 'avg_lr' in state: + lrs.append(state['avg_lr']) + if not lrs: + return None + return torch.stack(lrs) + + @torch.no_grad() + def step(self, closure=None): + """ + Performs a single optimization step + + Arguments: + closure (callable, optional): A closure that reevaluates the model + and returns the loss. + """ + self.step_hook() + loss = None + if closure is not None: + loss = closure() + + for group in self.param_groups: + for p in group["params"]: + if p.grad is None or not p.requires_grad: + continue + + grad = p.grad + if grad.dtype != torch.float32: + grad = grad.to(torch.float32) + if grad.is_sparse: + raise RuntimeError( + "Automagic does not support sparse gradients.") + + state = self.state[p] + grad_shape = grad.shape + + factored = len(grad_shape) >= 2 + # State Initialization + if len(state) == 0: + self.initialize_state(p) + else: + # Check if exp_avg_sq_row and exp_avg_sq_col exist for factored case + if factored: + if "exp_avg_sq_row" not in state or "exp_avg_sq_col" not in state: + state["exp_avg_sq_row"] = torch.zeros(p.shape[:-1]).to(grad) + state["exp_avg_sq_col"] = torch.zeros(p.shape[:-2] + p.shape[-1:]).to(grad) + else: + state["exp_avg_sq_row"] = state["exp_avg_sq_row"].to(grad) + state["exp_avg_sq_col"] = state["exp_avg_sq_col"].to(grad) + # Check if exp_avg_sq exists for non-factored case + else: + if "exp_avg_sq" not in state: + state["exp_avg_sq"] = torch.zeros_like(grad) + else: + state["exp_avg_sq"] = state["exp_avg_sq"].to(grad) + + p_data_fp32 = p + + if HAS_QBYTES and isinstance(p_data_fp32, QBytesTensor): + p_data_fp32 = p_data_fp32.dequantize() + if p.dtype != torch.float32: + p_data_fp32 = p_data_fp32.clone().float() + + # Initialize step if it doesn't exist + if "step" not in state: + state["step"] = 0 + state["step"] += 1 + state["RMS"] = self._rms(p_data_fp32) + + # Use fixed beta2 from group instead of decay_rate calculation + beta2 = group["beta2"] + eps = group["eps"] + if isinstance(eps, tuple) or isinstance(eps, list): + eps = eps[0] + update = (grad**2) + eps + if factored: + exp_avg_sq_row = state["exp_avg_sq_row"] + exp_avg_sq_col = state["exp_avg_sq_col"] + + exp_avg_sq_row.mul_(beta2).add_( + update.mean(dim=-1), alpha=(1.0 - beta2)) + exp_avg_sq_col.mul_(beta2).add_( + update.mean(dim=-2), alpha=(1.0 - beta2)) + + # Approximation of exponential moving average of square of gradient + update = self._approx_sq_grad( + exp_avg_sq_row, exp_avg_sq_col) + update.mul_(grad) + else: + exp_avg_sq = state["exp_avg_sq"] + + exp_avg_sq.mul_(beta2).add_(update, alpha=(1.0 - beta2)) + update = exp_avg_sq.rsqrt().mul_(grad) + + update.div_( + (self._rms(update) / group["clip_threshold"]).clamp_(min=1.0)) + + # Ensure state is properly initialized + if 'last_polarity' not in state or 'lr_mask' not in state: + self.initialize_state(p) + + # Get signs of current last update and updates + last_polarity = state['last_polarity'] + current_polarity = (update > 0).to(torch.bool) + sign_agreement = torch.where( + last_polarity == current_polarity, 1, -1) + state['last_polarity'] = current_polarity + + lr_mask = state['lr_mask'].to(torch.float32) + + # Update learning rate mask based on sign agreement + new_lr = torch.where( + sign_agreement > 0, + lr_mask + self.lr_bump, # Increase lr + lr_mask - self.lr_bump # Decrease lr + ) + + # Clip learning rates to bounds + new_lr = torch.clamp( + new_lr, + min=self.min_lr, + max=self.max_lr + ) + + # Apply the learning rate mask to the update + update.mul_(new_lr) + + state['lr_mask'] = Auto8bitTensor(new_lr) + state['avg_lr'] = torch.mean(new_lr) + + if group["weight_decay"] != 0: + # Apply weight decay with per-parameter learning rates + # Instead of using add_ with a tensor alpha (which isn't supported), + # we'll use element-wise multiplication to apply the weight decay + weight_decay_update = p_data_fp32 * (-group["weight_decay"]) * new_lr + else: + weight_decay_update = None + + if p.dtype == torch.bfloat16: + # Kahan summation for bfloat16 + update.mul_(-1) + if weight_decay_update is not None: + update.add_(weight_decay_update) + shift = state['shift'] + shift.add_(update) + # Use grad as temp buffer + grad.copy_(p.detach()) + p.add_(shift) + shift.add_(grad.sub_(p)) + else: + if weight_decay_update is not None: + p_data_fp32.add_(weight_decay_update) + p_data_fp32.add_(-update) + if p.dtype != torch.float32: + # apply stochastic rounding + copy_stochastic(p, p_data_fp32) + + return loss + + def initialize_state(self, p): + state = self.state[p] + state["step"] = 0 + + # store the lr mask + if 'lr_mask' not in state: + state['lr_mask'] = Auto8bitTensor(torch.ones( + p.shape).to(p.device, dtype=torch.float32) * self.lr + ) + state['avg_lr'] = torch.mean( + state['lr_mask'].to(torch.float32)) + if 'last_polarity' not in state: + state['last_polarity'] = torch.zeros( + p.shape, dtype=torch.bool, device=p.device) + + factored = len(p.shape) >= 2 + if factored: + state["exp_avg_sq_row"] = torch.zeros( + p.shape[:-1]).to(p) + state["exp_avg_sq_col"] = torch.zeros( + p.shape[:-2] + p.shape[-1:]).to(p) + else: + state["exp_avg_sq"] = torch.zeros_like(p) + + state["RMS"] = 0 + # For Kahan summation. + if p.dtype == torch.bfloat16: + state['shift'] = torch.zeros_like(p) + + # override the state_dict to save the lr_mask + def state_dict(self, *args, **kwargs): + orig_state_dict = super().state_dict(*args, **kwargs) + # convert the state to quantized tensor to scale and quantized + new_sace_state = {} + for p, state in orig_state_dict['state'].items(): + save_state = {k: v for k, v in state.items() if k != 'lr_mask'} + + # Check if lr_mask exists in the state before trying to access it + if 'lr_mask' in state: + save_state['lr_mask'] = state['lr_mask'].state_dict() + + new_sace_state[p] = save_state + + orig_state_dict['state'] = new_sace_state + + return orig_state_dict + + def load_state_dict(self, state_dict, strict=True): + # Validate that the state_dict is from an Automagic optimizer + is_valid_automagic_state = False + + # Check if state_dict has the expected structure + if 'state' in state_dict and isinstance(state_dict['state'], dict): + # Check if at least one state entry has an lr_mask, which is specific to Automagic + for param_id, param_state in state_dict['state'].items(): + if isinstance(param_state, dict) and 'lr_mask' in param_state: + is_valid_automagic_state = True + break + + if not is_valid_automagic_state: + return + + # First, call the parent class's load_state_dict to load the basic optimizer state + # We'll handle the lr_mask separately + state_dict_copy = { + 'state': {}, + 'param_groups': state_dict['param_groups'] + } + + # Copy all state entries except lr_mask + for param_id, param_state in state_dict['state'].items(): + state_dict_copy['state'][param_id] = { + k: v for k, v in param_state.items() if k != 'lr_mask' + } + + # Call parent class load_state_dict with the modified state dict + super().load_state_dict(state_dict_copy) + + # Now handle the lr_mask separately + # We need to map the saved parameters to the current parameters + # This is tricky because the parameter IDs might be different + + # Get all current parameters that require gradients + current_params = [] + for group in self.param_groups: + for p in group['params']: + if p.requires_grad: + current_params.append(p) + + # If the number of parameters doesn't match, we can't reliably map them + if len(current_params) != len(state_dict['param_groups'][0]['params']): + print(f"WARNING: Number of parameters doesn't match between saved state ({len(state_dict['param_groups'][0]['params'])}) " + f"and current model ({len(current_params)}). Learning rate masks may not be correctly loaded.") + + # Map parameters by their position in the param_groups + # This assumes the order of parameters is preserved between saving and loading + saved_param_ids = list(state_dict['state'].keys()) + + for i, current_param in enumerate(current_params): + if i >= len(saved_param_ids): + break + + saved_param_id = saved_param_ids[i] + saved_state = state_dict['state'][saved_param_id] + + # Skip if this saved state doesn't have an lr_mask + if 'lr_mask' not in saved_state: + continue + + # Initialize the state for this parameter if it doesn't exist + if current_param not in self.state: + self.initialize_state(current_param) + + # Get the current state for this parameter + current_state = self.state[current_param] + + # Load the lr_mask from the saved state + saved_lr_mask = saved_state['lr_mask'] + + # Reconstruct the Auto8bitTensor from its state dict + try: + # Make sure the shapes match + if 'quantized' in saved_lr_mask and saved_lr_mask['quantized'].shape == current_param.shape: + saved_lr_mask['quantized'] = saved_lr_mask['quantized'].to(current_param.device) + current_state['lr_mask'] = Auto8bitTensor(saved_lr_mask) + else: + print(f"WARNING: Shape mismatch for parameter {i}. " + f"Expected {current_param.shape}, got {saved_lr_mask['quantized'].shape if 'quantized' in saved_lr_mask else 'unknown'}. " + f"Initializing new lr_mask.") + # Initialize a new lr_mask + current_state['lr_mask'] = Auto8bitTensor(torch.ones( + current_param.shape).to(current_param.device, dtype=torch.float32) * self.lr + ) + except Exception as e: + print(f"ERROR: Failed to load lr_mask for parameter {i}: {e}") + # Initialize a new lr_mask + current_state['lr_mask'] = Auto8bitTensor(torch.ones( + current_param.shape).to(current_param.device, dtype=torch.float32) * self.lr + ) diff --git a/src/musubi_tuner/optimizers/optimizer_utils.py b/src/musubi_tuner/optimizers/optimizer_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8d418ab7e6a09db198a5ea22cc9e6c3e35542010 --- /dev/null +++ b/src/musubi_tuner/optimizers/optimizer_utils.py @@ -0,0 +1,286 @@ +# Copied from diffusion-pipe, originally from AI Toolkit. + +# MIT License + +# Copyright (c) 2024 Ostris, LLC + +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: + +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. + +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + + +import torch +from torch import Tensor +from typing import Optional + +try: + from optimum.quanto import QBytesTensor + HAS_QBYTES = True +except ImportError: + HAS_QBYTES = False + + +def compute_scale_for_dtype(tensor, dtype): + """ + Compute appropriate scale for the given tensor and target dtype. + + Args: + tensor: Input tensor to be quantized + dtype: Target dtype for quantization + Returns: + Appropriate scale factor for the quantization + """ + if dtype == torch.int8: + abs_max = torch.max(torch.abs(tensor)) + return abs_max / 127.0 if abs_max > 0 else 1.0 + elif dtype == torch.uint8: + max_val = torch.max(tensor) + min_val = torch.min(tensor) + range_val = max_val - min_val + return range_val / 255.0 if range_val > 0 else 1.0 + elif dtype in (torch.float8_e4m3fn, torch.float8_e5m2): + # For float8, we typically want to preserve the magnitude of the values + # while fitting within the representable range of the format + abs_max = torch.max(torch.abs(tensor)) + if dtype == torch.float8_e4m3fn: + # e4m3fn has range [-448, 448] with no infinities + max_representable = 448.0 + else: # torch.float8_e5m2 + # e5m2 has range [-57344, 57344] with infinities + max_representable = 57344.0 + + return abs_max / max_representable if abs_max > 0 else 1.0 + else: + raise ValueError(f"Unsupported dtype for quantization: {dtype}") + +def quantize_tensor(tensor, dtype): + """ + Quantize a floating-point tensor to the target dtype with appropriate scaling. + + Args: + tensor: Input tensor (float) + dtype: Target dtype for quantization + Returns: + quantized_data: Quantized tensor + scale: Scale factor used + """ + scale = compute_scale_for_dtype(tensor, dtype) + + if dtype == torch.int8: + quantized_data = torch.clamp(torch.round(tensor / scale), -128, 127).to(dtype) + elif dtype == torch.uint8: + quantized_data = torch.clamp(torch.round(tensor / scale), 0, 255).to(dtype) + elif dtype in (torch.float8_e4m3fn, torch.float8_e5m2): + # For float8, we scale and then cast directly to the target type + # The casting operation will handle the appropriate rounding + scaled_tensor = tensor / scale + quantized_data = scaled_tensor.to(dtype) + else: + raise ValueError(f"Unsupported dtype for quantization: {dtype}") + + return quantized_data, scale + + +def update_parameter(target, result_float): + """ + Updates a parameter tensor, handling both regular torch.Tensor and QBytesTensor cases + with proper rescaling for quantized tensors. + + Args: + target: The parameter to update (either torch.Tensor or QBytesTensor) + result_float: The new values to assign (torch.Tensor) + """ + if HAS_QBYTES and isinstance(target, QBytesTensor): + # Get the target dtype from the existing quantized tensor + target_dtype = target._data.dtype + + # Handle device placement + device = target._data.device + result_float = result_float.to(device) + + # Compute new quantized values and scale + quantized_data, new_scale = quantize_tensor(result_float, target_dtype) + + # Update the internal tensors with newly computed values + target._data.copy_(quantized_data) + target._scale.copy_(new_scale) + else: + # Regular tensor update + target.copy_(result_float) + + +def get_format_params(dtype: torch.dtype) -> tuple[int, int]: + """ + Returns (mantissa_bits, total_bits) for each format. + mantissa_bits excludes the implicit leading 1. + """ + if dtype == torch.float32: + return 23, 32 + elif dtype == torch.bfloat16: + return 7, 16 + elif dtype == torch.float16: + return 10, 16 + elif dtype == torch.float8_e4m3fn: + return 3, 8 + elif dtype == torch.float8_e5m2: + return 2, 8 + elif dtype == torch.int8: + return 0, 8 # Int8 doesn't have mantissa bits + else: + raise ValueError(f"Unsupported dtype: {dtype}") + + +def copy_stochastic( + target: torch.Tensor, + source: torch.Tensor, + eps: Optional[float] = None +) -> None: + """ + Performs stochastic rounding from source tensor to target tensor. + + Args: + target: Destination tensor (determines the target format) + source: Source tensor (typically float32) + eps: Optional minimum value for stochastic rounding (for numerical stability) + """ + with torch.no_grad(): + # If target is float32, just copy directly + if target.dtype == torch.float32: + target.copy_(source) + return + + # Special handling for int8 + if target.dtype == torch.int8: + # Scale the source values to utilize the full int8 range + scaled = source * 127.0 # Scale to [-127, 127] + + # Add random noise for stochastic rounding + noise = torch.rand_like(scaled) - 0.5 + rounded = torch.round(scaled + noise) + + # Clamp to int8 range + clamped = torch.clamp(rounded, -127, 127) + target.copy_(clamped.to(torch.int8)) + return + + mantissa_bits, _ = get_format_params(target.dtype) + + # Convert source to int32 view + source_int = source.view(dtype=torch.int32) + + # Calculate number of bits to round + bits_to_round = 23 - mantissa_bits # 23 is float32 mantissa bits + + # Create random integers for stochastic rounding + rand = torch.randint_like( + source, + dtype=torch.int32, + low=0, + high=(1 << bits_to_round), + ) + + # Add random values to the bits that will be rounded off + result = source_int.clone() + result.add_(rand) + + # Mask to keep only the bits we want + # Create mask with 1s in positions we want to keep + mask = (-1) << bits_to_round + result.bitwise_and_(mask) + + # Handle minimum value threshold if specified + if eps is not None: + eps_int = torch.tensor( + eps, dtype=torch.float32).view(dtype=torch.int32) + zero_mask = (result.abs() < eps_int) + result[zero_mask] = torch.sign(source_int[zero_mask]) * eps_int + + # Convert back to float32 view + result_float = result.view(dtype=torch.float32) + + # Special handling for float8 formats + if target.dtype == torch.float8_e4m3fn: + result_float.clamp_(-448.0, 448.0) + elif target.dtype == torch.float8_e5m2: + result_float.clamp_(-57344.0, 57344.0) + + # Copy the result to the target tensor + update_parameter(target, result_float) + # target.copy_(result_float) + del result, rand, source_int + + +class Auto8bitTensor: + def __init__(self, data: Tensor, *args, **kwargs): + if isinstance(data, dict): # Add constructor from state dict + self._load_from_state_dict(data) + else: + abs_max = data.abs().max().item() + scale = abs_max / 127.0 if abs_max > 0 else 1.0 + + self.quantized = (data / scale).round().clamp(-127, 127).to(torch.int8) + self.scale = scale + self.orig_dtype = data.dtype + + def dequantize(self) -> Tensor: + return self.quantized.to(dtype=torch.float32) * self.scale + + def to(self, *args, **kwargs): + # Handle the dtype argument whether it's positional or keyword + dtype = None + if args and isinstance(args[0], torch.dtype): + dtype = args[0] + args = args[1:] + elif 'dtype' in kwargs: + dtype = kwargs['dtype'] + del kwargs['dtype'] + + if dtype is not None: + # First dequantize then convert to requested dtype + return self.dequantize().to(dtype=dtype, *args, **kwargs) + + # If no dtype specified, just pass through to parent + return self.dequantize().to(*args, **kwargs) + + def state_dict(self): + """Returns a dictionary containing the current state of the tensor.""" + return { + 'quantized': self.quantized, + 'scale': self.scale, + 'orig_dtype': self.orig_dtype + } + + def _load_from_state_dict(self, state_dict): + """Loads the tensor state from a state dictionary.""" + self.quantized = state_dict['quantized'] + self.scale = state_dict['scale'] + self.orig_dtype = state_dict['orig_dtype'] + + def __str__(self): + return f"Auto8bitTensor({self.dequantize()})" + + +def stochastic_grad_accummulation(param): + if hasattr(param, "_accum_grad"): + grad_fp32 = param._accum_grad.clone().to(torch.float32) + grad_fp32.add_(param.grad.to(torch.float32)) + copy_stochastic(param._accum_grad, grad_fp32) + del grad_fp32 + del param.grad + else: + param._accum_grad = param.grad.clone() + del param.grad diff --git a/src/musubi_tuner/qwen_image/qwen_image_autoencoder_kl.py b/src/musubi_tuner/qwen_image/qwen_image_autoencoder_kl.py new file mode 100644 index 0000000000000000000000000000000000000000..8d1730cfc7251122e641ecbc75cd97ebb2f4d78e --- /dev/null +++ b/src/musubi_tuner/qwen_image/qwen_image_autoencoder_kl.py @@ -0,0 +1,1201 @@ +# Copied and modified from Diffusers. Original copyright notice follows. + +# Copyright 2025 The Qwen-Image Team, Wan Team and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# We gratefully acknowledge the Wan Team for their outstanding contributions. +# QwenImageVAE is further fine-tuned from the Wan Video VAE to achieve improved performance. +# For more information about the Wan VAE, please refer to: +# - GitHub: https://github.com/Wan-Video/Wan2.1 +# - arXiv: https://arxiv.org/abs/2503.20314 + +from typing import Dict, List, Optional, Tuple, Union + +import torch +import torch.nn as nn +import torch.nn.functional as F +import numpy as np + +from musubi_tuner.qwen_image.qwen_image_modules import get_activation + +import logging + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +CACHE_T = 2 + + +# region diffusers-vae + + +class DiagonalGaussianDistribution(object): + def __init__(self, parameters: torch.Tensor, deterministic: bool = False): + self.parameters = parameters + self.mean, self.logvar = torch.chunk(parameters, 2, dim=1) + self.logvar = torch.clamp(self.logvar, -30.0, 20.0) + self.deterministic = deterministic + self.std = torch.exp(0.5 * self.logvar) + self.var = torch.exp(self.logvar) + if self.deterministic: + self.var = self.std = torch.zeros_like(self.mean, device=self.parameters.device, dtype=self.parameters.dtype) + + def sample(self, generator: Optional[torch.Generator] = None) -> torch.Tensor: + # make sure sample is on the same device as the parameters and has same dtype + if generator is not None and generator.device.type != self.parameters.device.type: + rand_device = generator.device + else: + rand_device = self.parameters.device + sample = torch.randn(self.mean.shape, generator=generator, device=rand_device, dtype=self.parameters.dtype).to( + self.parameters.device + ) + x = self.mean + self.std * sample + return x + + def kl(self, other: "DiagonalGaussianDistribution" = None) -> torch.Tensor: + if self.deterministic: + return torch.Tensor([0.0]) + else: + if other is None: + return 0.5 * torch.sum( + torch.pow(self.mean, 2) + self.var - 1.0 - self.logvar, + dim=[1, 2, 3], + ) + else: + return 0.5 * torch.sum( + torch.pow(self.mean - other.mean, 2) / other.var + self.var / other.var - 1.0 - self.logvar + other.logvar, + dim=[1, 2, 3], + ) + + def nll(self, sample: torch.Tensor, dims: Tuple[int, ...] = [1, 2, 3]) -> torch.Tensor: + if self.deterministic: + return torch.Tensor([0.0]) + logtwopi = np.log(2.0 * np.pi) + return 0.5 * torch.sum( + logtwopi + self.logvar + torch.pow(sample - self.mean, 2) / self.var, + dim=dims, + ) + + def mode(self) -> torch.Tensor: + return self.mean + + +# endregion diffusers-vae + + +class QwenImageCausalConv3d(nn.Conv3d): + r""" + A custom 3D causal convolution layer with feature caching support. + + This layer extends the standard Conv3D layer by ensuring causality in the time dimension and handling feature + caching for efficient inference. + + Args: + in_channels (int): Number of channels in the input image + out_channels (int): Number of channels produced by the convolution + kernel_size (int or tuple): Size of the convolving kernel + stride (int or tuple, optional): Stride of the convolution. Default: 1 + padding (int or tuple, optional): Zero-padding added to all three sides of the input. Default: 0 + """ + + def __init__( + self, + in_channels: int, + out_channels: int, + kernel_size: Union[int, Tuple[int, int, int]], + stride: Union[int, Tuple[int, int, int]] = 1, + padding: Union[int, Tuple[int, int, int]] = 0, + ) -> None: + super().__init__( + in_channels=in_channels, + out_channels=out_channels, + kernel_size=kernel_size, + stride=stride, + padding=padding, + ) + + # Set up causal padding + self._padding = (self.padding[2], self.padding[2], self.padding[1], self.padding[1], 2 * self.padding[0], 0) + self.padding = (0, 0, 0) + + def forward(self, x, cache_x=None): + padding = list(self._padding) + if cache_x is not None and self._padding[4] > 0: + cache_x = cache_x.to(x.device) + x = torch.cat([cache_x, x], dim=2) + padding[4] -= cache_x.shape[2] + x = F.pad(x, padding) + return super().forward(x) + + +class QwenImageRMS_norm(nn.Module): + r""" + A custom RMS normalization layer. + + Args: + dim (int): The number of dimensions to normalize over. + channel_first (bool, optional): Whether the input tensor has channels as the first dimension. + Default is True. + images (bool, optional): Whether the input represents image data. Default is True. + bias (bool, optional): Whether to include a learnable bias term. Default is False. + """ + + def __init__(self, dim: int, channel_first: bool = True, images: bool = True, bias: bool = False) -> None: + super().__init__() + broadcastable_dims = (1, 1, 1) if not images else (1, 1) + shape = (dim, *broadcastable_dims) if channel_first else (dim,) + + self.channel_first = channel_first + self.scale = dim**0.5 + self.gamma = nn.Parameter(torch.ones(shape)) + self.bias = nn.Parameter(torch.zeros(shape)) if bias else 0.0 + + def forward(self, x): + return F.normalize(x, dim=(1 if self.channel_first else -1)) * self.scale * self.gamma + self.bias + + +class QwenImageUpsample(nn.Upsample): + r""" + Perform upsampling while ensuring the output tensor has the same data type as the input. + + Args: + x (torch.Tensor): Input tensor to be upsampled. + + Returns: + torch.Tensor: Upsampled tensor with the same data type as the input. + """ + + def forward(self, x): + return super().forward(x.float()).type_as(x) + + +class QwenImageResample(nn.Module): + r""" + A custom resampling module for 2D and 3D data. + + Args: + dim (int): The number of input/output channels. + mode (str): The resampling mode. Must be one of: + - 'none': No resampling (identity operation). + - 'upsample2d': 2D upsampling with nearest-exact interpolation and convolution. + - 'upsample3d': 3D upsampling with nearest-exact interpolation, convolution, and causal 3D convolution. + - 'downsample2d': 2D downsampling with zero-padding and convolution. + - 'downsample3d': 3D downsampling with zero-padding, convolution, and causal 3D convolution. + """ + + def __init__(self, dim: int, mode: str) -> None: + super().__init__() + self.dim = dim + self.mode = mode + + # layers + if mode == "upsample2d": + self.resample = nn.Sequential( + QwenImageUpsample(scale_factor=(2.0, 2.0), mode="nearest-exact"), + nn.Conv2d(dim, dim // 2, 3, padding=1), + ) + elif mode == "upsample3d": + self.resample = nn.Sequential( + QwenImageUpsample(scale_factor=(2.0, 2.0), mode="nearest-exact"), + nn.Conv2d(dim, dim // 2, 3, padding=1), + ) + self.time_conv = QwenImageCausalConv3d(dim, dim * 2, (3, 1, 1), padding=(1, 0, 0)) + + elif mode == "downsample2d": + self.resample = nn.Sequential(nn.ZeroPad2d((0, 1, 0, 1)), nn.Conv2d(dim, dim, 3, stride=(2, 2))) + elif mode == "downsample3d": + self.resample = nn.Sequential(nn.ZeroPad2d((0, 1, 0, 1)), nn.Conv2d(dim, dim, 3, stride=(2, 2))) + self.time_conv = QwenImageCausalConv3d(dim, dim, (3, 1, 1), stride=(2, 1, 1), padding=(0, 0, 0)) + + else: + self.resample = nn.Identity() + + def forward(self, x, feat_cache=None, feat_idx=[0]): + b, c, t, h, w = x.size() + if self.mode == "upsample3d": + if feat_cache is not None: + idx = feat_idx[0] + if feat_cache[idx] is None: + feat_cache[idx] = "Rep" + feat_idx[0] += 1 + else: + cache_x = x[:, :, -CACHE_T:, :, :].clone() + if cache_x.shape[2] < 2 and feat_cache[idx] is not None and feat_cache[idx] != "Rep": + # cache last frame of last two chunk + cache_x = torch.cat([feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(cache_x.device), cache_x], dim=2) + if cache_x.shape[2] < 2 and feat_cache[idx] is not None and feat_cache[idx] == "Rep": + cache_x = torch.cat([torch.zeros_like(cache_x).to(cache_x.device), cache_x], dim=2) + if feat_cache[idx] == "Rep": + x = self.time_conv(x) + else: + x = self.time_conv(x, feat_cache[idx]) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + + x = x.reshape(b, 2, c, t, h, w) + x = torch.stack((x[:, 0, :, :, :, :], x[:, 1, :, :, :, :]), 3) + x = x.reshape(b, c, t * 2, h, w) + t = x.shape[2] + x = x.permute(0, 2, 1, 3, 4).reshape(b * t, c, h, w) + x = self.resample(x) + x = x.view(b, t, x.size(1), x.size(2), x.size(3)).permute(0, 2, 1, 3, 4) + + if self.mode == "downsample3d": + if feat_cache is not None: + idx = feat_idx[0] + if feat_cache[idx] is None: + feat_cache[idx] = x.clone() + feat_idx[0] += 1 + else: + cache_x = x[:, :, -1:, :, :].clone() + x = self.time_conv(torch.cat([feat_cache[idx][:, :, -1:, :, :], x], 2)) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + return x + + +class QwenImageResidualBlock(nn.Module): + r""" + A custom residual block module. + + Args: + in_dim (int): Number of input channels. + out_dim (int): Number of output channels. + dropout (float, optional): Dropout rate for the dropout layer. Default is 0.0. + non_linearity (str, optional): Type of non-linearity to use. Default is "silu". + """ + + def __init__( + self, + in_dim: int, + out_dim: int, + dropout: float = 0.0, + non_linearity: str = "silu", + ) -> None: + super().__init__() + self.in_dim = in_dim + self.out_dim = out_dim + self.nonlinearity = get_activation(non_linearity) + + # layers + self.norm1 = QwenImageRMS_norm(in_dim, images=False) + self.conv1 = QwenImageCausalConv3d(in_dim, out_dim, 3, padding=1) + self.norm2 = QwenImageRMS_norm(out_dim, images=False) + self.dropout = nn.Dropout(dropout) + self.conv2 = QwenImageCausalConv3d(out_dim, out_dim, 3, padding=1) + self.conv_shortcut = QwenImageCausalConv3d(in_dim, out_dim, 1) if in_dim != out_dim else nn.Identity() + + def forward(self, x, feat_cache=None, feat_idx=[0]): + # Apply shortcut connection + h = self.conv_shortcut(x) + + # First normalization and activation + x = self.norm1(x) + x = self.nonlinearity(x) + + if feat_cache is not None: + idx = feat_idx[0] + cache_x = x[:, :, -CACHE_T:, :, :].clone() + if cache_x.shape[2] < 2 and feat_cache[idx] is not None: + cache_x = torch.cat([feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(cache_x.device), cache_x], dim=2) + + x = self.conv1(x, feat_cache[idx]) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + else: + x = self.conv1(x) + + # Second normalization and activation + x = self.norm2(x) + x = self.nonlinearity(x) + + # Dropout + x = self.dropout(x) + + if feat_cache is not None: + idx = feat_idx[0] + cache_x = x[:, :, -CACHE_T:, :, :].clone() + if cache_x.shape[2] < 2 and feat_cache[idx] is not None: + cache_x = torch.cat([feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(cache_x.device), cache_x], dim=2) + + x = self.conv2(x, feat_cache[idx]) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + else: + x = self.conv2(x) + + # Add residual connection + return x + h + + +class QwenImageAttentionBlock(nn.Module): + r""" + Causal self-attention with a single head. + + Args: + dim (int): The number of channels in the input tensor. + """ + + def __init__(self, dim): + super().__init__() + self.dim = dim + + # layers + self.norm = QwenImageRMS_norm(dim) + self.to_qkv = nn.Conv2d(dim, dim * 3, 1) + self.proj = nn.Conv2d(dim, dim, 1) + + def forward(self, x): + identity = x + batch_size, channels, time, height, width = x.size() + + x = x.permute(0, 2, 1, 3, 4).reshape(batch_size * time, channels, height, width) + x = self.norm(x) + + # compute query, key, value + qkv = self.to_qkv(x) + qkv = qkv.reshape(batch_size * time, 1, channels * 3, -1) + qkv = qkv.permute(0, 1, 3, 2).contiguous() + q, k, v = qkv.chunk(3, dim=-1) + + # apply attention + x = F.scaled_dot_product_attention(q, k, v) + + x = x.squeeze(1).permute(0, 2, 1).reshape(batch_size * time, channels, height, width) + + # output projection + x = self.proj(x) + + # Reshape back: [(b*t), c, h, w] -> [b, c, t, h, w] + x = x.view(batch_size, time, channels, height, width) + x = x.permute(0, 2, 1, 3, 4) + + return x + identity + + +class QwenImageMidBlock(nn.Module): + """ + Middle block for QwenImageVAE encoder and decoder. + + Args: + dim (int): Number of input/output channels. + dropout (float): Dropout rate. + non_linearity (str): Type of non-linearity to use. + """ + + def __init__(self, dim: int, dropout: float = 0.0, non_linearity: str = "silu", num_layers: int = 1): + super().__init__() + self.dim = dim + + # Create the components + resnets = [QwenImageResidualBlock(dim, dim, dropout, non_linearity)] + attentions = [] + for _ in range(num_layers): + attentions.append(QwenImageAttentionBlock(dim)) + resnets.append(QwenImageResidualBlock(dim, dim, dropout, non_linearity)) + self.attentions = nn.ModuleList(attentions) + self.resnets = nn.ModuleList(resnets) + + self.gradient_checkpointing = False + + def forward(self, x, feat_cache=None, feat_idx=[0]): + # First residual block + x = self.resnets[0](x, feat_cache, feat_idx) + + # Process through attention and residual blocks + for attn, resnet in zip(self.attentions, self.resnets[1:]): + if attn is not None: + x = attn(x) + + x = resnet(x, feat_cache, feat_idx) + + return x + + +class QwenImageEncoder3d(nn.Module): + r""" + A 3D encoder module. + + Args: + dim (int): The base number of channels in the first layer. + z_dim (int): The dimensionality of the latent space. + dim_mult (list of int): Multipliers for the number of channels in each block. + num_res_blocks (int): Number of residual blocks in each block. + attn_scales (list of float): Scales at which to apply attention mechanisms. + temperal_downsample (list of bool): Whether to downsample temporally in each block. + dropout (float): Dropout rate for the dropout layers. + input_channels (int): Number of input channels. + non_linearity (str): Type of non-linearity to use. + """ + + def __init__( + self, + dim=128, + z_dim=4, + dim_mult=[1, 2, 4, 4], + num_res_blocks=2, + attn_scales=[], + temperal_downsample=[True, True, False], + dropout=0.0, + input_channels: int = 3, + non_linearity: str = "silu", + ): + super().__init__() + self.dim = dim + self.z_dim = z_dim + self.dim_mult = dim_mult + self.num_res_blocks = num_res_blocks + self.attn_scales = attn_scales + self.temperal_downsample = temperal_downsample + self.nonlinearity = get_activation(non_linearity) + + # dimensions + dims = [dim * u for u in [1] + dim_mult] + scale = 1.0 + + # init block + self.conv_in = QwenImageCausalConv3d(input_channels, dims[0], 3, padding=1) + + # downsample blocks + self.down_blocks = nn.ModuleList([]) + for i, (in_dim, out_dim) in enumerate(zip(dims[:-1], dims[1:])): + # residual (+attention) blocks + for _ in range(num_res_blocks): + self.down_blocks.append(QwenImageResidualBlock(in_dim, out_dim, dropout)) + if scale in attn_scales: + self.down_blocks.append(QwenImageAttentionBlock(out_dim)) + in_dim = out_dim + + # downsample block + if i != len(dim_mult) - 1: + mode = "downsample3d" if temperal_downsample[i] else "downsample2d" + self.down_blocks.append(QwenImageResample(out_dim, mode=mode)) + scale /= 2.0 + + # middle blocks + self.mid_block = QwenImageMidBlock(out_dim, dropout, non_linearity, num_layers=1) + + # output blocks + self.norm_out = QwenImageRMS_norm(out_dim, images=False) + self.conv_out = QwenImageCausalConv3d(out_dim, z_dim, 3, padding=1) + + self.gradient_checkpointing = False + + def forward(self, x, feat_cache=None, feat_idx=[0]): + if feat_cache is not None: + idx = feat_idx[0] + cache_x = x[:, :, -CACHE_T:, :, :].clone() + if cache_x.shape[2] < 2 and feat_cache[idx] is not None: + # cache last frame of last two chunk + cache_x = torch.cat([feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(cache_x.device), cache_x], dim=2) + x = self.conv_in(x, feat_cache[idx]) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + else: + x = self.conv_in(x) + + ## downsamples + for layer in self.down_blocks: + if feat_cache is not None: + x = layer(x, feat_cache, feat_idx) + else: + x = layer(x) + + ## middle + x = self.mid_block(x, feat_cache, feat_idx) + + ## head + x = self.norm_out(x) + x = self.nonlinearity(x) + if feat_cache is not None: + idx = feat_idx[0] + cache_x = x[:, :, -CACHE_T:, :, :].clone() + if cache_x.shape[2] < 2 and feat_cache[idx] is not None: + # cache last frame of last two chunk + cache_x = torch.cat([feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(cache_x.device), cache_x], dim=2) + x = self.conv_out(x, feat_cache[idx]) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + else: + x = self.conv_out(x) + return x + + +class QwenImageUpBlock(nn.Module): + """ + A block that handles upsampling for the QwenImageVAE decoder. + + Args: + in_dim (int): Input dimension + out_dim (int): Output dimension + num_res_blocks (int): Number of residual blocks + dropout (float): Dropout rate + upsample_mode (str, optional): Mode for upsampling ('upsample2d' or 'upsample3d') + non_linearity (str): Type of non-linearity to use + """ + + def __init__( + self, + in_dim: int, + out_dim: int, + num_res_blocks: int, + dropout: float = 0.0, + upsample_mode: Optional[str] = None, + non_linearity: str = "silu", + ): + super().__init__() + self.in_dim = in_dim + self.out_dim = out_dim + + # Create layers list + resnets = [] + # Add residual blocks and attention if needed + current_dim = in_dim + for _ in range(num_res_blocks + 1): + resnets.append(QwenImageResidualBlock(current_dim, out_dim, dropout, non_linearity)) + current_dim = out_dim + + self.resnets = nn.ModuleList(resnets) + + # Add upsampling layer if needed + self.upsamplers = None + if upsample_mode is not None: + self.upsamplers = nn.ModuleList([QwenImageResample(out_dim, mode=upsample_mode)]) + + self.gradient_checkpointing = False + + def forward(self, x, feat_cache=None, feat_idx=[0]): + """ + Forward pass through the upsampling block. + + Args: + x (torch.Tensor): Input tensor + feat_cache (list, optional): Feature cache for causal convolutions + feat_idx (list, optional): Feature index for cache management + + Returns: + torch.Tensor: Output tensor + """ + for resnet in self.resnets: + if feat_cache is not None: + x = resnet(x, feat_cache, feat_idx) + else: + x = resnet(x) + + if self.upsamplers is not None: + if feat_cache is not None: + x = self.upsamplers[0](x, feat_cache, feat_idx) + else: + x = self.upsamplers[0](x) + return x + + +class QwenImageDecoder3d(nn.Module): + r""" + A 3D decoder module. + + Args: + dim (int): The base number of channels in the first layer. + z_dim (int): The dimensionality of the latent space. + dim_mult (list of int): Multipliers for the number of channels in each block. + num_res_blocks (int): Number of residual blocks in each block. + attn_scales (list of float): Scales at which to apply attention mechanisms. + temperal_upsample (list of bool): Whether to upsample temporally in each block. + dropout (float): Dropout rate for the dropout layers. + output_channels (int): Number of output channels. + non_linearity (str): Type of non-linearity to use. + """ + + def __init__( + self, + dim=128, + z_dim=4, + dim_mult=[1, 2, 4, 4], + num_res_blocks=2, + attn_scales=[], + temperal_upsample=[False, True, True], + dropout=0.0, + output_channels: int = 3, + non_linearity: str = "silu", + ): + super().__init__() + self.dim = dim + self.z_dim = z_dim + self.dim_mult = dim_mult + self.num_res_blocks = num_res_blocks + self.attn_scales = attn_scales + self.temperal_upsample = temperal_upsample + + self.nonlinearity = get_activation(non_linearity) + + # dimensions + dims = [dim * u for u in [dim_mult[-1]] + dim_mult[::-1]] + scale = 1.0 / 2 ** (len(dim_mult) - 2) + + # init block + self.conv_in = QwenImageCausalConv3d(z_dim, dims[0], 3, padding=1) + + # middle blocks + self.mid_block = QwenImageMidBlock(dims[0], dropout, non_linearity, num_layers=1) + + # upsample blocks + self.up_blocks = nn.ModuleList([]) + for i, (in_dim, out_dim) in enumerate(zip(dims[:-1], dims[1:])): + # residual (+attention) blocks + if i > 0: + in_dim = in_dim // 2 + + # Determine if we need upsampling + upsample_mode = None + if i != len(dim_mult) - 1: + upsample_mode = "upsample3d" if temperal_upsample[i] else "upsample2d" + + # Create and add the upsampling block + up_block = QwenImageUpBlock( + in_dim=in_dim, + out_dim=out_dim, + num_res_blocks=num_res_blocks, + dropout=dropout, + upsample_mode=upsample_mode, + non_linearity=non_linearity, + ) + self.up_blocks.append(up_block) + + # Update scale for next iteration + if upsample_mode is not None: + scale *= 2.0 + + # output blocks + self.norm_out = QwenImageRMS_norm(out_dim, images=False) + self.conv_out = QwenImageCausalConv3d(out_dim, output_channels, 3, padding=1) + + self.gradient_checkpointing = False + + def forward(self, x, feat_cache=None, feat_idx=[0]): + ## conv1 + if feat_cache is not None: + idx = feat_idx[0] + cache_x = x[:, :, -CACHE_T:, :, :].clone() + if cache_x.shape[2] < 2 and feat_cache[idx] is not None: + # cache last frame of last two chunk + cache_x = torch.cat([feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(cache_x.device), cache_x], dim=2) + x = self.conv_in(x, feat_cache[idx]) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + else: + x = self.conv_in(x) + + ## middle + x = self.mid_block(x, feat_cache, feat_idx) + + ## upsamples + for up_block in self.up_blocks: + x = up_block(x, feat_cache, feat_idx) + + ## head + x = self.norm_out(x) + x = self.nonlinearity(x) + if feat_cache is not None: + idx = feat_idx[0] + cache_x = x[:, :, -CACHE_T:, :, :].clone() + if cache_x.shape[2] < 2 and feat_cache[idx] is not None: + # cache last frame of last two chunk + cache_x = torch.cat([feat_cache[idx][:, :, -1, :, :].unsqueeze(2).to(cache_x.device), cache_x], dim=2) + x = self.conv_out(x, feat_cache[idx]) + feat_cache[idx] = cache_x + feat_idx[0] += 1 + else: + x = self.conv_out(x) + return x + + +class AutoencoderKLQwenImage(nn.Module): # ModelMixin, ConfigMixin, FromOriginalModelMixin): + r""" + A VAE model with KL loss for encoding videos into latents and decoding latent representations into videos. + + This model inherits from [`ModelMixin`]. Check the superclass documentation for it's generic methods implemented + for all models (such as downloading or saving). + """ + + _supports_gradient_checkpointing = False + + # @register_to_config + def __init__( + self, + base_dim: int = 96, + z_dim: int = 16, + dim_mult: Tuple[int] = [1, 2, 4, 4], + num_res_blocks: int = 2, + attn_scales: List[float] = [], + temperal_downsample: List[bool] = [False, True, True], + dropout: float = 0.0, + latents_mean: List[float] = [ + -0.7571, + -0.7089, + -0.9113, + 0.1075, + -0.1745, + 0.9653, + -0.1517, + 1.5508, + 0.4134, + -0.0715, + 0.5517, + -0.3632, + -0.1922, + -0.9497, + 0.2503, + -0.2921, + ], + latents_std: List[float] = [ + 2.8184, + 1.4541, + 2.3275, + 2.6558, + 1.2196, + 1.7708, + 2.6052, + 2.0743, + 3.2687, + 2.1526, + 2.8652, + 1.5579, + 1.6382, + 1.1253, + 2.8251, + 1.9160, + ], + input_channels: int = 3, + ) -> None: + super().__init__() + + self.z_dim = z_dim + self.temperal_downsample = temperal_downsample + self.temperal_upsample = temperal_downsample[::-1] + self.latents_mean = latents_mean + self.latents_std = latents_std + + self.encoder = QwenImageEncoder3d( + base_dim, z_dim * 2, dim_mult, num_res_blocks, attn_scales, self.temperal_downsample, dropout, input_channels + ) + self.quant_conv = QwenImageCausalConv3d(z_dim * 2, z_dim * 2, 1) + self.post_quant_conv = QwenImageCausalConv3d(z_dim, z_dim, 1) + + self.decoder = QwenImageDecoder3d( + base_dim, z_dim, dim_mult, num_res_blocks, attn_scales, self.temperal_upsample, dropout, input_channels + ) + + self.spatial_compression_ratio = 2 ** len(self.temperal_downsample) + + # When decoding a batch of video latents at a time, one can save memory by slicing across the batch dimension + # to perform decoding of a single video latent at a time. + self.use_slicing = False + + # When decoding spatially large video latents, the memory requirement is very high. By breaking the video latent + # frames spatially into smaller tiles and performing multiple forward passes for decoding, and then blending the + # intermediate tiles together, the memory requirement can be lowered. + self.use_tiling = False + + # The minimal tile height and width for spatial tiling to be used + self.tile_sample_min_height = 256 + self.tile_sample_min_width = 256 + + # The minimal distance between two spatial tiles + self.tile_sample_stride_height = 192 + self.tile_sample_stride_width = 192 + + # Precompute and cache conv counts for encoder and decoder for clear_cache speedup + self._cached_conv_counts = { + "decoder": sum(isinstance(m, QwenImageCausalConv3d) for m in self.decoder.modules()) if self.decoder is not None else 0, + "encoder": sum(isinstance(m, QwenImageCausalConv3d) for m in self.encoder.modules()) if self.encoder is not None else 0, + } + + @property + def dtype(self): + return self.encoder.parameters().__next__().dtype + + @property + def device(self): + return self.encoder.parameters().__next__().device + + def enable_tiling( + self, + tile_sample_min_height: Optional[int] = None, + tile_sample_min_width: Optional[int] = None, + tile_sample_stride_height: Optional[float] = None, + tile_sample_stride_width: Optional[float] = None, + ) -> None: + r""" + Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to + compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow + processing larger images. + + Args: + tile_sample_min_height (`int`, *optional*): + The minimum height required for a sample to be separated into tiles across the height dimension. + tile_sample_min_width (`int`, *optional*): + The minimum width required for a sample to be separated into tiles across the width dimension. + tile_sample_stride_height (`int`, *optional*): + The minimum amount of overlap between two consecutive vertical tiles. This is to ensure that there are + no tiling artifacts produced across the height dimension. + tile_sample_stride_width (`int`, *optional*): + The stride between two consecutive horizontal tiles. This is to ensure that there are no tiling + artifacts produced across the width dimension. + """ + self.use_tiling = True + self.tile_sample_min_height = tile_sample_min_height or self.tile_sample_min_height + self.tile_sample_min_width = tile_sample_min_width or self.tile_sample_min_width + self.tile_sample_stride_height = tile_sample_stride_height or self.tile_sample_stride_height + self.tile_sample_stride_width = tile_sample_stride_width or self.tile_sample_stride_width + + def disable_tiling(self) -> None: + r""" + Disable tiled VAE decoding. If `enable_tiling` was previously enabled, this method will go back to computing + decoding in one step. + """ + self.use_tiling = False + + def enable_slicing(self) -> None: + r""" + Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to + compute decoding in several steps. This is useful to save some memory and allow larger batch sizes. + """ + self.use_slicing = True + + def disable_slicing(self) -> None: + r""" + Disable sliced VAE decoding. If `enable_slicing` was previously enabled, this method will go back to computing + decoding in one step. + """ + self.use_slicing = False + + def clear_cache(self): + def _count_conv3d(model): + count = 0 + for m in model.modules(): + if isinstance(m, QwenImageCausalConv3d): + count += 1 + return count + + self._conv_num = _count_conv3d(self.decoder) + self._conv_idx = [0] + self._feat_map = [None] * self._conv_num + # cache encode + self._enc_conv_num = _count_conv3d(self.encoder) + self._enc_conv_idx = [0] + self._enc_feat_map = [None] * self._enc_conv_num + + def _encode(self, x: torch.Tensor): + _, _, num_frame, height, width = x.shape + + if self.use_tiling and (width > self.tile_sample_min_width or height > self.tile_sample_min_height): + return self.tiled_encode(x) + + self.clear_cache() + iter_ = 1 + (num_frame - 1) // 4 + for i in range(iter_): + self._enc_conv_idx = [0] + if i == 0: + out = self.encoder(x[:, :, :1, :, :], feat_cache=self._enc_feat_map, feat_idx=self._enc_conv_idx) + else: + out_ = self.encoder( + x[:, :, 1 + 4 * (i - 1) : 1 + 4 * i, :, :], + feat_cache=self._enc_feat_map, + feat_idx=self._enc_conv_idx, + ) + out = torch.cat([out, out_], 2) + + enc = self.quant_conv(out) + self.clear_cache() + return enc + + # @apply_forward_hook + def encode( + self, x: torch.Tensor, return_dict: bool = True + ) -> Union[Dict[str, torch.Tensor], Tuple[DiagonalGaussianDistribution]]: + r""" + Encode a batch of images into latents. + + Args: + x (`torch.Tensor`): Input batch of images. + return_dict (`bool`, *optional*, defaults to `True`): + Whether to return a [`~models.autoencoder_kl.AutoencoderKLOutput`] instead of a plain tuple. + + Returns: + The latent representations of the encoded videos. If `return_dict` is True, a dictionary is returned, otherwise a plain `tuple` is returned. + """ + if self.use_slicing and x.shape[0] > 1: + encoded_slices = [self._encode(x_slice) for x_slice in x.split(1)] + h = torch.cat(encoded_slices) + else: + h = self._encode(x) + posterior = DiagonalGaussianDistribution(h) + + if not return_dict: + return (posterior,) + return {"latent_dist": posterior} + + def _decode(self, z: torch.Tensor, return_dict: bool = True): + _, _, num_frame, height, width = z.shape + tile_latent_min_height = self.tile_sample_min_height // self.spatial_compression_ratio + tile_latent_min_width = self.tile_sample_min_width // self.spatial_compression_ratio + + if self.use_tiling and (width > tile_latent_min_width or height > tile_latent_min_height): + return self.tiled_decode(z, return_dict=return_dict) + + self.clear_cache() + x = self.post_quant_conv(z) + for i in range(num_frame): + self._conv_idx = [0] + if i == 0: + out = self.decoder(x[:, :, i : i + 1, :, :], feat_cache=self._feat_map, feat_idx=self._conv_idx) + else: + out_ = self.decoder(x[:, :, i : i + 1, :, :], feat_cache=self._feat_map, feat_idx=self._conv_idx) + out = torch.cat([out, out_], 2) + + out = torch.clamp(out, min=-1.0, max=1.0) + self.clear_cache() + if not return_dict: + return (out,) + + return {"sample": out} + + # @apply_forward_hook + def decode(self, z: torch.Tensor, return_dict: bool = True) -> Union[Dict[str, torch.Tensor], torch.Tensor]: + r""" + Decode a batch of images. + + Args: + z (`torch.Tensor`): Input batch of latent vectors. + return_dict (`bool`, *optional*, defaults to `True`): + Whether to return a [`~models.vae.DecoderOutput`] instead of a plain tuple. + + Returns: + [`~models.vae.DecoderOutput`] or `tuple`: + If return_dict is True, a [`~models.vae.DecoderOutput`] is returned, otherwise a plain `tuple` is + returned. + """ + if self.use_slicing and z.shape[0] > 1: + decoded_slices = [self._decode(z_slice)["sample"] for z_slice in z.split(1)] + decoded = torch.cat(decoded_slices) + else: + decoded = self._decode(z)["sample"] + + if not return_dict: + return (decoded,) + return {"sample": decoded} + + def decode_to_pixels(self, latents: torch.Tensor) -> torch.Tensor: + vae_scale_factor = 2 ** len(self.temperal_downsample) + # latents = qwen_image_utils.unpack_latents(latent, height, width, vae_scale_factor) + latents = latents.to(self.dtype) + latents_mean = torch.tensor(self.latents_mean).view(1, self.z_dim, 1, 1, 1).to(latents.device, latents.dtype) + latents_std = 1.0 / torch.tensor(self.latents_std).view(1, self.z_dim, 1, 1, 1).to(latents.device, latents.dtype) + latents = latents / latents_std + latents_mean + image = self.decode(latents, return_dict=False)[0][:, :, 0] # -1 to 1 + return (image * 0.5 + 0.5).clamp(0.0, 1.0) # Convert to [0, 1] range + + def encode_pixels_to_latents(self, pixels: torch.Tensor) -> torch.Tensor: + """ + Convert pixel values to latents and apply normalization using mean/std. + + Args: + pixels (torch.Tensor): Input pixels in [0, 1] range with shape [B, C, H, W] or [B, C, T, H, W] + + Returns: + torch.Tensor: Normalized latents + """ + # # Convert from [0, 1] to [-1, 1] range + # pixels = (pixels * 2.0 - 1.0).clamp(-1.0, 1.0) + + # Handle 2D input by adding temporal dimension + if pixels.dim() == 4: + pixels = pixels.unsqueeze(2) # [B, C, H, W] -> [B, C, 1, H, W] + + pixels = pixels.to(self.dtype) + + # Encode to latent space + posterior = self.encode(pixels, return_dict=False)[0] + latents = posterior.mode() # Use mode instead of sampling for deterministic results + # latents = posterior.sample() + + # Apply normalization using mean/std + latents_mean = torch.tensor(self.latents_mean).view(1, self.z_dim, 1, 1, 1).to(latents.device, latents.dtype) + latents_std = 1.0 / torch.tensor(self.latents_std).view(1, self.z_dim, 1, 1, 1).to(latents.device, latents.dtype) + latents = (latents - latents_mean) * latents_std + + return latents + + def blend_v(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor: + blend_extent = min(a.shape[-2], b.shape[-2], blend_extent) + for y in range(blend_extent): + b[:, :, :, y, :] = a[:, :, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, :, y, :] * (y / blend_extent) + return b + + def blend_h(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor: + blend_extent = min(a.shape[-1], b.shape[-1], blend_extent) + for x in range(blend_extent): + b[:, :, :, :, x] = a[:, :, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, :, x] * (x / blend_extent) + return b + + def tiled_encode(self, x: torch.Tensor) -> torch.Tensor: + r"""Encode a batch of images using a tiled encoder. + + Args: + x (`torch.Tensor`): Input batch of videos. + + Returns: + `torch.Tensor`: + The latent representation of the encoded videos. + """ + _, _, num_frames, height, width = x.shape + latent_height = height // self.spatial_compression_ratio + latent_width = width // self.spatial_compression_ratio + + tile_latent_min_height = self.tile_sample_min_height // self.spatial_compression_ratio + tile_latent_min_width = self.tile_sample_min_width // self.spatial_compression_ratio + tile_latent_stride_height = self.tile_sample_stride_height // self.spatial_compression_ratio + tile_latent_stride_width = self.tile_sample_stride_width // self.spatial_compression_ratio + + blend_height = tile_latent_min_height - tile_latent_stride_height + blend_width = tile_latent_min_width - tile_latent_stride_width + + # Split x into overlapping tiles and encode them separately. + # The tiles have an overlap to avoid seams between tiles. + rows = [] + for i in range(0, height, self.tile_sample_stride_height): + row = [] + for j in range(0, width, self.tile_sample_stride_width): + self.clear_cache() + time = [] + frame_range = 1 + (num_frames - 1) // 4 + for k in range(frame_range): + self._enc_conv_idx = [0] + if k == 0: + tile = x[:, :, :1, i : i + self.tile_sample_min_height, j : j + self.tile_sample_min_width] + else: + tile = x[ + :, + :, + 1 + 4 * (k - 1) : 1 + 4 * k, + i : i + self.tile_sample_min_height, + j : j + self.tile_sample_min_width, + ] + tile = self.encoder(tile, feat_cache=self._enc_feat_map, feat_idx=self._enc_conv_idx) + tile = self.quant_conv(tile) + time.append(tile) + row.append(torch.cat(time, dim=2)) + rows.append(row) + self.clear_cache() + + result_rows = [] + for i, row in enumerate(rows): + result_row = [] + for j, tile in enumerate(row): + # blend the above tile and the left tile + # to the current tile and add the current tile to the result row + if i > 0: + tile = self.blend_v(rows[i - 1][j], tile, blend_height) + if j > 0: + tile = self.blend_h(row[j - 1], tile, blend_width) + result_row.append(tile[:, :, :, :tile_latent_stride_height, :tile_latent_stride_width]) + result_rows.append(torch.cat(result_row, dim=-1)) + + enc = torch.cat(result_rows, dim=3)[:, :, :, :latent_height, :latent_width] + return enc + + def tiled_decode(self, z: torch.Tensor, return_dict: bool = True) -> Union[Dict[str, torch.Tensor], torch.Tensor]: + r""" + Decode a batch of images using a tiled decoder. + + Args: + z (`torch.Tensor`): Input batch of latent vectors. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a dictionary instead of a plain tuple. + + Returns: + `dict` or `tuple`: + If return_dict is True, a dictionary is returned, otherwise a plain `tuple` is + returned. + """ + _, _, num_frames, height, width = z.shape + sample_height = height * self.spatial_compression_ratio + sample_width = width * self.spatial_compression_ratio + + tile_latent_min_height = self.tile_sample_min_height // self.spatial_compression_ratio + tile_latent_min_width = self.tile_sample_min_width // self.spatial_compression_ratio + tile_latent_stride_height = self.tile_sample_stride_height // self.spatial_compression_ratio + tile_latent_stride_width = self.tile_sample_stride_width // self.spatial_compression_ratio + + blend_height = self.tile_sample_min_height - self.tile_sample_stride_height + blend_width = self.tile_sample_min_width - self.tile_sample_stride_width + + # Split z into overlapping tiles and decode them separately. + # The tiles have an overlap to avoid seams between tiles. + rows = [] + for i in range(0, height, tile_latent_stride_height): + row = [] + for j in range(0, width, tile_latent_stride_width): + self.clear_cache() + time = [] + for k in range(num_frames): + self._conv_idx = [0] + tile = z[:, :, k : k + 1, i : i + tile_latent_min_height, j : j + tile_latent_min_width] + tile = self.post_quant_conv(tile) + decoded = self.decoder(tile, feat_cache=self._feat_map, feat_idx=self._conv_idx) + time.append(decoded) + row.append(torch.cat(time, dim=2)) + rows.append(row) + self.clear_cache() + + result_rows = [] + for i, row in enumerate(rows): + result_row = [] + for j, tile in enumerate(row): + # blend the above tile and the left tile + # to the current tile and add the current tile to the result row + if i > 0: + tile = self.blend_v(rows[i - 1][j], tile, blend_height) + if j > 0: + tile = self.blend_h(row[j - 1], tile, blend_width) + result_row.append(tile[:, :, :, : self.tile_sample_stride_height, : self.tile_sample_stride_width]) + result_rows.append(torch.cat(result_row, dim=-1)) + + dec = torch.cat(result_rows, dim=3)[:, :, :, :sample_height, :sample_width] + + if not return_dict: + return (dec,) + return {"sample": dec} + + def forward( + self, + sample: torch.Tensor, + sample_posterior: bool = False, + return_dict: bool = True, + generator: Optional[torch.Generator] = None, + ) -> Union[Dict[str, torch.Tensor], torch.Tensor]: + """ + Args: + sample (`torch.Tensor`): Input sample. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`Dict[str, torch.Tensor]`] instead of a plain tuple. + """ + x = sample + posterior = self.encode(x).latent_dist + if sample_posterior: + z = posterior.sample(generator=generator) + else: + z = posterior.mode() + dec = self.decode(z, return_dict=return_dict) + return dec diff --git a/src/musubi_tuner/qwen_image/qwen_image_model.py b/src/musubi_tuner/qwen_image/qwen_image_model.py new file mode 100644 index 0000000000000000000000000000000000000000..c8986044ba7509967171854917d8d185e0beb862 --- /dev/null +++ b/src/musubi_tuner/qwen_image/qwen_image_model.py @@ -0,0 +1,1523 @@ +# Copied and modified from Diffusers. Original copyright notice follows. + +# Copyright 2025 Qwen-Image Team and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import inspect +import numbers +from typing import Any, Dict, List, Optional, Tuple, Union +import math +from math import prod + +# import numpy as np +import torch +from torch import nn +from torch.nn import functional as F +from accelerate import init_empty_weights + +from musubi_tuner.modules.custom_offloading_utils import ModelOffloader +from musubi_tuner.modules.fp8_optimization_utils import apply_fp8_monkey_patch +from musubi_tuner.qwen_image.qwen_image_modules import get_activation +from musubi_tuner.hunyuan_model.attention import attention as hunyuan_attention + +import logging + +from musubi_tuner.utils.lora_utils import load_safetensors_with_lora_and_fp8 +from musubi_tuner.utils.model_utils import create_cpu_offloading_wrapper + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +EXAMPLE_DOC_STRING = """ + Examples: + ```py + >>> import torch + >>> from diffusers import QwenImagePipeline + + >>> pipe = QwenImagePipeline.from_pretrained("Qwen/QwenImage-20B", torch_dtype=torch.bfloat16) + >>> pipe.to("cuda") + >>> prompt = "A cat holding a sign that says hello world" + >>> # Depending on the variant being used, the pipeline call will slightly vary. + >>> # Refer to the pipeline documentation for more details. + >>> image = pipe(prompt, num_inference_steps=4, guidance_scale=0.0).images[0] + >>> image.save("qwenimage.png") + ``` +""" + + +def calculate_shift( + image_seq_len, + base_seq_len: int = 256, + max_seq_len: int = 4096, + base_shift: float = 0.5, + max_shift: float = 1.15, +): + m = (max_shift - base_shift) / (max_seq_len - base_seq_len) + b = base_shift - m * base_seq_len + mu = image_seq_len * m + b + return mu + + +# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps +def retrieve_timesteps( + scheduler, + num_inference_steps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + timesteps: Optional[List[int]] = None, + sigmas: Optional[List[float]] = None, + **kwargs, +): + r""" + Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles + custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`. + + Args: + scheduler (`SchedulerMixin`): + The scheduler to get timesteps from. + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps` + must be `None`. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`List[int]`, *optional*): + Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed, + `num_inference_steps` and `sigmas` must be `None`. + sigmas (`List[float]`, *optional*): + Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed, + `num_inference_steps` and `timesteps` must be `None`. + + Returns: + `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the + second element is the number of inference steps. + """ + if timesteps is not None and sigmas is not None: + raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values") + if timesteps is not None: + accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accepts_timesteps: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" timestep schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + elif sigmas is not None: + accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + if not accept_sigmas: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" sigmas schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + else: + scheduler.set_timesteps(num_inference_steps, device=device, **kwargs) + timesteps = scheduler.timesteps + return timesteps, num_inference_steps + + +def get_timestep_embedding( + timesteps: torch.Tensor, + embedding_dim: int, + flip_sin_to_cos: bool = False, + downscale_freq_shift: float = 1, + scale: float = 1, + max_period: int = 10000, +) -> torch.Tensor: + """ + This matches the implementation in Denoising Diffusion Probabilistic Models: Create sinusoidal timestep embeddings. + + Args + timesteps (torch.Tensor): + a 1-D Tensor of N indices, one per batch element. These may be fractional. + embedding_dim (int): + the dimension of the output. + flip_sin_to_cos (bool): + Whether the embedding order should be `cos, sin` (if True) or `sin, cos` (if False) + downscale_freq_shift (float): + Controls the delta between frequencies between dimensions + scale (float): + Scaling factor applied to the embeddings. + max_period (int): + Controls the maximum frequency of the embeddings + Returns + torch.Tensor: an [N x dim] Tensor of positional embeddings. + """ + assert len(timesteps.shape) == 1, "Timesteps should be a 1d-array" + + half_dim = embedding_dim // 2 + exponent = -math.log(max_period) * torch.arange(start=0, end=half_dim, dtype=torch.float32, device=timesteps.device) + exponent = exponent / (half_dim - downscale_freq_shift) + + emb = torch.exp(exponent) + emb = timesteps[:, None].float() * emb[None, :] + + # scale embeddings + emb = scale * emb + + # concat sine and cosine embeddings + emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=-1) + + # flip sine and cosine embeddings + if flip_sin_to_cos: + emb = torch.cat([emb[:, half_dim:], emb[:, :half_dim]], dim=-1) + + # zero pad + if embedding_dim % 2 == 1: + emb = torch.nn.functional.pad(emb, (0, 1, 0, 0)) + return emb + + +class TimestepEmbedding(nn.Module): + def __init__( + self, + in_channels: int, + time_embed_dim: int, + act_fn: str = "silu", + out_dim: int = None, + post_act_fn: Optional[str] = None, + cond_proj_dim=None, + sample_proj_bias=True, + ): + super().__init__() + + self.linear_1 = nn.Linear(in_channels, time_embed_dim, sample_proj_bias) + + if cond_proj_dim is not None: + self.cond_proj = nn.Linear(cond_proj_dim, in_channels, bias=False) + else: + self.cond_proj = None + + self.act = get_activation(act_fn) + + if out_dim is not None: + time_embed_dim_out = out_dim + else: + time_embed_dim_out = time_embed_dim + self.linear_2 = nn.Linear(time_embed_dim, time_embed_dim_out, sample_proj_bias) + + if post_act_fn is None: + self.post_act = None + else: + self.post_act = get_activation(post_act_fn) + + def forward(self, sample, condition=None): + if condition is not None: + sample = sample + self.cond_proj(condition) + sample = self.linear_1(sample) + + if self.act is not None: + sample = self.act(sample) + + sample = self.linear_2(sample) + + if self.post_act is not None: + sample = self.post_act(sample) + return sample + + +class Timesteps(nn.Module): + def __init__(self, num_channels: int, flip_sin_to_cos: bool, downscale_freq_shift: float, scale: int = 1): + super().__init__() + self.num_channels = num_channels + self.flip_sin_to_cos = flip_sin_to_cos + self.downscale_freq_shift = downscale_freq_shift + self.scale = scale + + def forward(self, timesteps: torch.Tensor) -> torch.Tensor: + t_emb = get_timestep_embedding( + timesteps, + self.num_channels, + flip_sin_to_cos=self.flip_sin_to_cos, + downscale_freq_shift=self.downscale_freq_shift, + scale=self.scale, + ) + return t_emb + + +class QwenTimestepProjEmbeddings(nn.Module): + def __init__(self, embedding_dim, use_additional_t_cond=False): + super().__init__() + + self.time_proj = Timesteps(num_channels=256, flip_sin_to_cos=True, downscale_freq_shift=0, scale=1000) + self.timestep_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim) + self.use_additional_t_cond = use_additional_t_cond + if use_additional_t_cond: + self.addition_t_embedding = nn.Embedding(2, embedding_dim) + + def forward(self, timestep, hidden_states, addition_t_cond=None): + timesteps_proj = self.time_proj(timestep) + timesteps_emb = self.timestep_embedder(timesteps_proj.to(dtype=hidden_states.dtype)) # (N, D) + conditioning = timesteps_emb + + if self.use_additional_t_cond: + if addition_t_cond is None: + raise ValueError("When additional_t_cond is True, addition_t_cond must be provided.") + addition_t_emb = self.addition_t_embedding(addition_t_cond) + addition_t_emb = addition_t_emb.to(dtype=hidden_states.dtype) + conditioning = conditioning + addition_t_emb + + return conditioning + + +class QwenEmbedRope(nn.Module): + def __init__(self, theta: int, axes_dim: List[int], scale_rope=False): + super().__init__() + self.theta = theta + self.axes_dim = axes_dim + pos_index = torch.arange(4096) + neg_index = torch.arange(4096).flip(0) * -1 - 1 + self.pos_freqs = torch.cat( + [ + self.rope_params(pos_index, self.axes_dim[0], self.theta), + self.rope_params(pos_index, self.axes_dim[1], self.theta), + self.rope_params(pos_index, self.axes_dim[2], self.theta), + ], + dim=1, + ) + self.neg_freqs = torch.cat( + [ + self.rope_params(neg_index, self.axes_dim[0], self.theta), + self.rope_params(neg_index, self.axes_dim[1], self.theta), + self.rope_params(neg_index, self.axes_dim[2], self.theta), + ], + dim=1, + ) + self.rope_cache = {} + + # DO NOT USE REGISTER BUFFER HERE, IT WILL CAUSE COMPLEX NUMBERS TO LOSE THEIR IMAGINARY PART + self.scale_rope = scale_rope + + def rope_params(self, index, dim, theta=10000): + """ + Args: + index: [0, 1, 2, 3] 1D Tensor representing the position index of the token + """ + assert dim % 2 == 0 + freqs = torch.outer(index, 1.0 / torch.pow(theta, torch.arange(0, dim, 2).to(torch.float32).div(dim))) + freqs = torch.polar(torch.ones_like(freqs), freqs) + return freqs + + def forward(self, video_fhw, txt_seq_lens, device): + """ + Args: video_fhw: [frame, height, width] a list of 3 integers representing the shape of the video Args: + txt_length: [bs] a list of 1 integers representing the length of the text + """ + if self.pos_freqs.device != device: + self.pos_freqs = self.pos_freqs.to(device) + self.neg_freqs = self.neg_freqs.to(device) + + if isinstance(video_fhw, list): # if list of lists + video_fhw = video_fhw[0] + if not isinstance(video_fhw, list): # if video_fhw is tuple + video_fhw = [video_fhw] + + vid_freqs = [] + max_vid_index = 0 + for idx, fhw in enumerate(video_fhw): + frame, height, width = fhw + rope_key = f"{idx}_{height}_{width}" + + if rope_key not in self.rope_cache: + self.rope_cache[rope_key] = self._compute_video_freqs(frame, height, width, idx) + video_freq = self.rope_cache[rope_key] + video_freq = video_freq.to(device) + vid_freqs.append(video_freq) + + if self.scale_rope: + max_vid_index = max(height // 2, width // 2, max_vid_index) + else: + max_vid_index = max(height, width, max_vid_index) + + max_len = max(txt_seq_lens) + txt_freqs = self.pos_freqs[max_vid_index : max_vid_index + max_len, ...] + vid_freqs = torch.cat(vid_freqs, dim=0) + + return vid_freqs, txt_freqs + + # @functools.lru_cache(maxsize=None) + def _compute_video_freqs(self, frame, height, width, idx=0): + seq_lens = frame * height * width + freqs_pos = self.pos_freqs.split([x // 2 for x in self.axes_dim], dim=1) + freqs_neg = self.neg_freqs.split([x // 2 for x in self.axes_dim], dim=1) + + freqs_frame = freqs_pos[0][idx : idx + frame].view(frame, 1, 1, -1).expand(frame, height, width, -1) + if self.scale_rope: + freqs_height = torch.cat([freqs_neg[1][-(height - height // 2) :], freqs_pos[1][: height // 2]], dim=0) + freqs_height = freqs_height.view(1, height, 1, -1).expand(frame, height, width, -1) + freqs_width = torch.cat([freqs_neg[2][-(width - width // 2) :], freqs_pos[2][: width // 2]], dim=0) + freqs_width = freqs_width.view(1, 1, width, -1).expand(frame, height, width, -1) + else: + freqs_height = freqs_pos[1][:height].view(1, height, 1, -1).expand(frame, height, width, -1) + freqs_width = freqs_pos[2][:width].view(1, 1, width, -1).expand(frame, height, width, -1) + + freqs = torch.cat([freqs_frame, freqs_height, freqs_width], dim=-1).reshape(seq_lens, -1) + return freqs.clone().contiguous() + + +class QwenEmbedLayer3DRope(QwenEmbedRope): + def __init__(self, theta: int, axes_dim: List[int], scale_rope=False): + super().__init__(theta, axes_dim, scale_rope) + + def forward(self, video_fhw, txt_seq_lens, device): + """ + Args: video_fhw: [frame, height, width] a list of 3 integers representing the shape of the video Args: + txt_length: [bs] a list of 1 integers representing the length of the text + """ + if self.pos_freqs.device != device: + self.pos_freqs = self.pos_freqs.to(device) + self.neg_freqs = self.neg_freqs.to(device) + + if isinstance(video_fhw, list): + video_fhw = video_fhw[0] + if not isinstance(video_fhw, list): + video_fhw = [video_fhw] + + vid_freqs = [] + max_vid_index = 0 + layer_num = len(video_fhw) - 1 + for idx, fhw in enumerate(video_fhw): + frame, height, width = fhw + is_cond = idx == layer_num + rope_key = f"{is_cond}_{idx}_{height}_{width}" + if rope_key not in self.rope_cache: + if not is_cond: + video_freq = self._compute_video_freqs(frame, height, width, idx) + else: + ### For the condition image, we set the layer index to -1 + video_freq = self._compute_condition_freqs(frame, height, width) + self.rope_cache[rope_key] = video_freq + video_freq = self.rope_cache[rope_key] + video_freq = video_freq.to(device) + vid_freqs.append(video_freq) + + if self.scale_rope: + max_vid_index = max(height // 2, width // 2, max_vid_index) + else: + max_vid_index = max(height, width, max_vid_index) + + max_vid_index = max(max_vid_index, layer_num) + max_len = max(txt_seq_lens) + txt_freqs = self.pos_freqs[max_vid_index : max_vid_index + max_len, ...] + vid_freqs = torch.cat(vid_freqs, dim=0) + + return vid_freqs, txt_freqs + + # @functools.lru_cache(maxsize=None) + def _compute_condition_freqs(self, frame, height, width): + seq_lens = frame * height * width + freqs_pos = self.pos_freqs.split([x // 2 for x in self.axes_dim], dim=1) + freqs_neg = self.neg_freqs.split([x // 2 for x in self.axes_dim], dim=1) + + freqs_frame = freqs_neg[0][-1:].view(frame, 1, 1, -1).expand(frame, height, width, -1) + if self.scale_rope: + freqs_height = torch.cat([freqs_neg[1][-(height - height // 2) :], freqs_pos[1][: height // 2]], dim=0) + freqs_height = freqs_height.view(1, height, 1, -1).expand(frame, height, width, -1) + freqs_width = torch.cat([freqs_neg[2][-(width - width // 2) :], freqs_pos[2][: width // 2]], dim=0) + freqs_width = freqs_width.view(1, 1, width, -1).expand(frame, height, width, -1) + else: + freqs_height = freqs_pos[1][:height].view(1, height, 1, -1).expand(frame, height, width, -1) + freqs_width = freqs_pos[2][:width].view(1, 1, width, -1).expand(frame, height, width, -1) + + freqs = torch.cat([freqs_frame, freqs_height, freqs_width], dim=-1).reshape(seq_lens, -1) + return freqs.clone().contiguous() + + +class RMSNorm(nn.Module): + r""" + RMS Norm as introduced in https://huggingface.co/papers/1910.07467 by Zhang et al. + + Args: + dim (`int`): Number of dimensions to use for `weights`. Only effective when `elementwise_affine` is True. + eps (`float`): Small value to use when calculating the reciprocal of the square-root. + elementwise_affine (`bool`, defaults to `True`): + Boolean flag to denote if affine transformation should be applied. + bias (`bool`, defaults to False): If also training the `bias` param. + """ + + def __init__(self, dim, eps: float, elementwise_affine: bool = True, bias: bool = False): + super().__init__() + + self.eps = eps + self.elementwise_affine = elementwise_affine + + if isinstance(dim, numbers.Integral): + dim = (dim,) + + self.dim = torch.Size(dim) + + self.weight = None + self.bias = None + + if elementwise_affine: + self.weight = nn.Parameter(torch.ones(dim)) + if bias: + self.bias = nn.Parameter(torch.zeros(dim)) + + def forward(self, hidden_states): + # if is_torch_npu_available(): + # import torch_npu + # if self.weight is not None: + # # convert into half-precision if necessary + # if self.weight.dtype in [torch.float16, torch.bfloat16]: + # hidden_states = hidden_states.to(self.weight.dtype) + # hidden_states = torch_npu.npu_rms_norm(hidden_states, self.weight, epsilon=self.eps)[0] + # if self.bias is not None: + # hidden_states = hidden_states + self.bias + # else: + input_dtype = hidden_states.dtype + variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + self.eps) + + if self.weight is not None: + # convert into half-precision if necessary + if self.weight.dtype in [torch.float16, torch.bfloat16]: + hidden_states = hidden_states.to(self.weight.dtype) + elif self.weight.dtype == torch.float8_e4m3fn: # fp8 support + hidden_states = hidden_states * self.weight.to(hidden_states.dtype) + hidden_states = hidden_states + (self.bias.to(hidden_states.dtype) if self.bias is not None else 0) + hidden_states = hidden_states.to(input_dtype) + return hidden_states + + hidden_states = hidden_states * self.weight + if self.bias is not None: + hidden_states = hidden_states + self.bias + else: + hidden_states = hidden_states.to(input_dtype) + + return hidden_states + + +class AdaLayerNormContinuous(nn.Module): + r""" + Adaptive normalization layer with a norm layer (layer_norm or rms_norm). + + Args: + embedding_dim (`int`): Embedding dimension to use during projection. + conditioning_embedding_dim (`int`): Dimension of the input condition. + elementwise_affine (`bool`, defaults to `True`): + Boolean flag to denote if affine transformation should be applied. + eps (`float`, defaults to 1e-5): Epsilon factor. + bias (`bias`, defaults to `True`): Boolean flag to denote if bias should be use. + norm_type (`str`, defaults to `"layer_norm"`): + Normalization layer to use. Values supported: "layer_norm", "rms_norm". + """ + + def __init__( + self, + embedding_dim: int, + conditioning_embedding_dim: int, + # NOTE: It is a bit weird that the norm layer can be configured to have scale and shift parameters + # because the output is immediately scaled and shifted by the projected conditioning embeddings. + # Note that AdaLayerNorm does not let the norm layer have scale and shift parameters. + # However, this is how it was implemented in the original code, and it's rather likely you should + # set `elementwise_affine` to False. + elementwise_affine=True, + eps=1e-5, + bias=True, + norm_type="layer_norm", + ): + super().__init__() + self.silu = nn.SiLU() + self.linear = nn.Linear(conditioning_embedding_dim, embedding_dim * 2, bias=bias) + if norm_type == "layer_norm": + self.norm = nn.LayerNorm(embedding_dim, eps, elementwise_affine, bias) + elif norm_type == "rms_norm": + self.norm = RMSNorm(embedding_dim, eps, elementwise_affine) + else: + raise ValueError(f"unknown norm_type {norm_type}") + + def forward(self, x: torch.Tensor, conditioning_embedding: torch.Tensor) -> torch.Tensor: + # convert back to the original dtype in case `conditioning_embedding`` is upcasted to float32 (needed for hunyuanDiT) + emb = self.linear(self.silu(conditioning_embedding).to(x.dtype)) + scale, shift = torch.chunk(emb, 2, dim=1) + x = self.norm(x) * (1 + scale)[:, None, :] + shift[:, None, :] + return x + + +class GELU(nn.Module): + r""" + GELU activation function with tanh approximation support with `approximate="tanh"`. + + Parameters: + dim_in (`int`): The number of channels in the input. + dim_out (`int`): The number of channels in the output. + approximate (`str`, *optional*, defaults to `"none"`): If `"tanh"`, use tanh approximation. + bias (`bool`, defaults to True): Whether to use a bias in the linear layer. + """ + + def __init__(self, dim_in: int, dim_out: int, approximate: str = "none", bias: bool = True): + super().__init__() + self.proj = nn.Linear(dim_in, dim_out, bias=bias) + self.approximate = approximate + + def gelu(self, gate: torch.Tensor) -> torch.Tensor: + # if gate.device.type == "mps" and is_torch_version("<", "2.0.0"): + # # fp16 gelu not supported on mps before torch 2.0 + # return F.gelu(gate.to(dtype=torch.float32), approximate=self.approximate).to(dtype=gate.dtype) + return F.gelu(gate, approximate=self.approximate) + + def forward(self, hidden_states): + hidden_states = self.proj(hidden_states) + hidden_states = self.gelu(hidden_states) + return hidden_states + + +class FeedForward(nn.Module): + r""" + A feed-forward layer. + + Parameters: + dim (`int`): The number of channels in the input. + dim_out (`int`, *optional*): The number of channels in the output. If not given, defaults to `dim`. + mult (`int`, *optional*, defaults to 4): The multiplier to use for the hidden dimension. + dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use. + activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to be used in feed-forward. + final_dropout (`bool` *optional*, defaults to False): Apply a final dropout. + bias (`bool`, defaults to True): Whether to use a bias in the linear layer. + """ + + def __init__( + self, + dim: int, + dim_out: Optional[int] = None, + mult: int = 4, + dropout: float = 0.0, + activation_fn: str = "geglu", + final_dropout: bool = False, + inner_dim=None, + bias: bool = True, + ): + super().__init__() + if inner_dim is None: + inner_dim = int(dim * mult) + dim_out = dim_out if dim_out is not None else dim + + if activation_fn == "gelu-approximate": + act_fn = GELU(dim, inner_dim, approximate="tanh", bias=bias) + else: + raise ValueError(f"Unknown activation function: {activation_fn}") + + self.net = nn.ModuleList([]) + # project in + self.net.append(act_fn) + # project dropout + self.net.append(nn.Dropout(dropout)) + # project out + self.net.append(nn.Linear(inner_dim, dim_out, bias=bias)) + # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout + if final_dropout: + self.net.append(nn.Dropout(dropout)) + + def forward(self, hidden_states: torch.Tensor, *args, **kwargs) -> torch.Tensor: + for module in self.net: + hidden_states = module(hidden_states) + return hidden_states + + +# torch.inductor does not support code generation for complex +# This breaks fullgraph=True +@torch.compiler.disable +def apply_rotary_emb_qwen( + x: torch.Tensor, + freqs_cis: Union[torch.Tensor, Tuple[torch.Tensor]], + use_real: bool = True, + use_real_unbind_dim: int = -1, +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Apply rotary embeddings to input tensors using the given frequency tensor. This function applies rotary embeddings + to the given query or key 'x' tensors using the provided frequency tensor 'freqs_cis'. The input tensors are + reshaped as complex numbers, and the frequency tensor is reshaped for broadcasting compatibility. The resulting + tensors contain rotary embeddings and are returned as real tensors. + + Args: + x (`torch.Tensor`): + Query or key tensor to apply rotary embeddings. [B, S, H, D] xk (torch.Tensor): Key tensor to apply + freqs_cis (`Tuple[torch.Tensor]`): Precomputed frequency tensor for complex exponentials. ([S, D], [S, D],) + + Returns: + Tuple[torch.Tensor, torch.Tensor]: Tuple of modified query tensor and key tensor with rotary embeddings. + """ + if use_real: + cos, sin = freqs_cis # [S, D] + cos = cos[None, None] + sin = sin[None, None] + cos, sin = cos.to(x.device), sin.to(x.device) + + if use_real_unbind_dim == -1: + # Used for flux, cogvideox, hunyuan-dit + x_real, x_imag = x.reshape(*x.shape[:-1], -1, 2).unbind(-1) # [B, S, H, D//2] + x_rotated = torch.stack([-x_imag, x_real], dim=-1).flatten(3) + elif use_real_unbind_dim == -2: + # Used for Stable Audio, OmniGen, CogView4 and Cosmos + x_real, x_imag = x.reshape(*x.shape[:-1], 2, -1).unbind(-2) # [B, S, H, D//2] + x_rotated = torch.cat([-x_imag, x_real], dim=-1) + else: + raise ValueError(f"`use_real_unbind_dim={use_real_unbind_dim}` but should be -1 or -2.") + + out = (x.float() * cos + x_rotated.float() * sin).to(x.dtype) + + return out + else: + x_rotated = torch.view_as_complex(x.float().reshape(*x.shape[:-1], -1, 2)) + freqs_cis = freqs_cis.unsqueeze(1) + x_out = torch.view_as_real(x_rotated * freqs_cis).flatten(3) + + return x_out.type_as(x) + + +class Attention(nn.Module): + """ + Modified from Attention processor for Qwen double-stream architecture. + + Attention processor for Qwen double-stream architecture, matching DoubleStreamLayerMegatron logic. This processor + implements joint attention computation where text and image streams are processed together. + """ + + def __init__( + self, + query_dim: int, + cross_attention_dim: Optional[int] = None, + added_kv_proj_dim: Optional[int] = None, + dim_head: int = 64, + heads: int = 8, + out_dim: int = None, + context_pre_only=None, + bias: bool = False, + qk_norm: Optional[str] = None, + eps: float = 1e-5, + attn_mode: str = "torch", + split_attn: bool = False, + ): + super().__init__() + assert cross_attention_dim is None, "cross_attention_dim should be None for Qwen double-stream attention." + assert not context_pre_only, "context_pre_only should be False for Qwen double-stream attention." + assert bias, "bias should be True for Qwen double-stream attention." + assert qk_norm == "rms_norm", "qk_norm should be 'rms_norm' for Qwen double-stream attention." + assert added_kv_proj_dim is not None, "added_kv_proj_dim should not be None for Qwen double-stream attention." + + self.inner_dim = out_dim if out_dim is not None else dim_head * heads + self.inner_kv_dim = self.inner_dim # if kv_heads is None else dim_head * kv_heads + self.query_dim = query_dim + self.use_bias = bias + self.cross_attention_dim = cross_attention_dim if cross_attention_dim is not None else query_dim + self.out_dim = out_dim if out_dim is not None else query_dim + self.out_context_dim = query_dim + self.context_pre_only = context_pre_only + self.pre_only = False + + self.scale = dim_head**-0.5 + self.heads = out_dim // dim_head if out_dim is not None else heads + + self.added_kv_proj_dim = added_kv_proj_dim + + self.attn_mode = attn_mode + self.split_attn = split_attn + + self.norm_q = RMSNorm(dim_head, eps=eps) + self.norm_k = RMSNorm(dim_head, eps=eps) + + self.to_q = nn.Linear(query_dim, self.inner_dim, bias=bias) + self.to_k = nn.Linear(self.cross_attention_dim, self.inner_kv_dim, bias=bias) + self.to_v = nn.Linear(self.cross_attention_dim, self.inner_kv_dim, bias=bias) + + self.added_proj_bias = True # added_proj_bias + self.add_k_proj = nn.Linear(added_kv_proj_dim, self.inner_kv_dim, bias=True) + self.add_v_proj = nn.Linear(added_kv_proj_dim, self.inner_kv_dim, bias=True) + self.add_q_proj = nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True) + + self.to_out = nn.ModuleList([]) + self.to_out.append(nn.Linear(self.inner_dim, self.out_dim, bias=True)) + # self.to_out.append(nn.Dropout(dropout)) + self.to_out.append(nn.Identity()) # dropout=0.0 + + self.to_add_out = nn.Linear(self.inner_dim, self.out_context_dim, bias=True) + + self.norm_added_q = RMSNorm(dim_head, eps=eps) + self.norm_added_k = RMSNorm(dim_head, eps=eps) + + def forward( + self, + hidden_states: torch.FloatTensor, # Image stream + encoder_hidden_states: torch.FloatTensor = None, # Text stream + encoder_hidden_states_mask: torch.FloatTensor = None, + attention_mask: Optional[torch.FloatTensor] = None, # We ignore this and use encoder_hidden_states_mask instead + image_rotary_emb: Optional[torch.Tensor] = None, + txt_seq_lens: Optional[torch.Tensor] = None, + ) -> torch.FloatTensor: + if encoder_hidden_states is None and txt_seq_lens is None: + raise ValueError("QwenDoubleStreamAttnProcessor2_0 requires encoder_hidden_states (text stream) or txt_seq_lens.") + + # Compute QKV for image stream (sample projections) + img_query = self.to_q(hidden_states) + img_key = self.to_k(hidden_states) + img_value = self.to_v(hidden_states) + del hidden_states + + # Compute QKV for text stream (context projections) + txt_query = self.add_q_proj(encoder_hidden_states) + txt_key = self.add_k_proj(encoder_hidden_states) + txt_value = self.add_v_proj(encoder_hidden_states) + del encoder_hidden_states + + # Reshape for multi-head attention + img_query = img_query.unflatten(-1, (self.heads, -1)) + img_key = img_key.unflatten(-1, (self.heads, -1)) + img_value = img_value.unflatten(-1, (self.heads, -1)) + + txt_query = txt_query.unflatten(-1, (self.heads, -1)) + txt_key = txt_key.unflatten(-1, (self.heads, -1)) + txt_value = txt_value.unflatten(-1, (self.heads, -1)) + + # Apply QK normalization + img_query = self.norm_q(img_query) + img_key = self.norm_k(img_key) + txt_query = self.norm_added_q(txt_query) + txt_key = self.norm_added_k(txt_key) + + # Apply RoPE + if image_rotary_emb is not None: + img_freqs, txt_freqs = image_rotary_emb + img_query = apply_rotary_emb_qwen(img_query, img_freqs, use_real=False) + img_key = apply_rotary_emb_qwen(img_key, img_freqs, use_real=False) + txt_query = apply_rotary_emb_qwen(txt_query, txt_freqs, use_real=False) + txt_key = apply_rotary_emb_qwen(txt_key, txt_freqs, use_real=False) + seq_img = img_query.shape[1] + + # Concatenate for joint attention + # Order: [image, txt] + joint_query = torch.cat([img_query, txt_query], dim=1) + del img_query, txt_query + joint_key = torch.cat([img_key, txt_key], dim=1) + del img_key, txt_key + joint_value = torch.cat([img_value, txt_value], dim=1) + del img_value, txt_value + + # Compute joint attention + if not self.split_attn: + # create attention mask for joint attention + if encoder_hidden_states_mask is not None: + # encoder_hidden_states_mask: [B, S_txt] + attention_mask = torch.cat( + [ + torch.ones( + (encoder_hidden_states_mask.shape[0], seq_img), + device=encoder_hidden_states_mask.device, + dtype=torch.bool, + ), + encoder_hidden_states_mask.to(torch.bool), + ], + dim=1, + ) # [B, S_img + S_txt] + attention_mask = attention_mask[:, None, None, :] # [B, 1, 1, S] for scaled_dot_product_attention + else: + attention_mask = None + + # joint_query: [B, S, H, D], joint_key: [B, S, H, D], joint_value: [B, S, H, D] + total_len = seq_img + txt_seq_lens + qkv = [joint_query, joint_key, joint_value] + org_dtype = joint_query.dtype + del joint_query, joint_key, joint_value + joint_hidden_states = hunyuan_attention( + qkv, mode=self.attn_mode, attn_mask=attention_mask, total_len=total_len if self.split_attn else None + ) + # joint_hidden_states: [B, S, H*D] + + joint_hidden_states = joint_hidden_states.to(org_dtype) + + # Split attention outputs back + img_attn_output = joint_hidden_states[:, :seq_img, :] # Image part + txt_attn_output = joint_hidden_states[:, seq_img:, :] # Text part + del joint_hidden_states + + # Original implementation + # ---- + # # Concatenate for joint attention + # # Order: [text, image] + # joint_query = torch.cat([txt_query, img_query], dim=1) + # joint_key = torch.cat([txt_key, img_key], dim=1) + # joint_value = torch.cat([txt_value, img_value], dim=1) + + # # Compute joint attention + # # joint_query: [B, S, H, D], joint_key: [B, S, H, D], joint_value: [B, S, H, D] + # joint_query = joint_query.transpose(1, 2) # [B, H, S, D] + # joint_key = joint_key.transpose(1, 2) # [B, H, S, D] + # joint_value = joint_value.transpose(1, 2) # [B, H, S, D] + # joint_hidden_states = torch.nn.functional.scaled_dot_product_attention( + # joint_query, joint_key, joint_value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False + # ) + # # joint_hidden_states: [B, H, S, D] + # joint_hidden_states = joint_hidden_states.transpose(1, 2) # [B, S, H, D] + # # backend=self._attention_backend, + + # # Reshape back + # joint_hidden_states = joint_hidden_states.flatten(2, 3) + # joint_hidden_states = joint_hidden_states.to(joint_query.dtype) + + # # Split attention outputs back + # txt_attn_output = joint_hidden_states[:, :seq_txt, :] # Text part + # img_attn_output = joint_hidden_states[:, seq_txt:, :] # Image part + # ---- + + # Apply output projections + img_attn_output = self.to_out[0](img_attn_output) + img_attn_output = self.to_out[1](img_attn_output) # dropout + + txt_attn_output = self.to_add_out(txt_attn_output) + + return img_attn_output, txt_attn_output + + +# @maybe_allow_in_graph +class QwenImageTransformerBlock(nn.Module): + def __init__( + self, + dim: int, + num_attention_heads: int, + attention_head_dim: int, + qk_norm: str = "rms_norm", + eps: float = 1e-6, + attn_mode: str = "torch", + split_attn: bool = False, + zero_cond_t: bool = False, + ): + super().__init__() + + self.dim = dim + self.num_attention_heads = num_attention_heads + self.attention_head_dim = attention_head_dim + self.attn_mode = attn_mode + self.split_attn = split_attn + + # Image processing modules + self.img_mod = nn.Sequential( + nn.SiLU(), + nn.Linear(dim, 6 * dim, bias=True), # For scale, shift, gate for norm1 and norm2 + ) + self.img_norm1 = nn.LayerNorm(dim, elementwise_affine=False, eps=eps) + self.attn = Attention( + query_dim=dim, + cross_attention_dim=None, # Enable cross attention for joint computation + added_kv_proj_dim=dim, # Enable added KV projections for text stream + dim_head=attention_head_dim, + heads=num_attention_heads, + out_dim=dim, + context_pre_only=False, + bias=True, + qk_norm=qk_norm, + eps=eps, + attn_mode=attn_mode, + split_attn=split_attn, + ) + # processor=QwenDoubleStreamAttnProcessor2_0(), + self.img_norm2 = nn.LayerNorm(dim, elementwise_affine=False, eps=eps) + self.img_mlp = FeedForward(dim=dim, dim_out=dim, activation_fn="gelu-approximate") + + # Text processing modules + self.txt_mod = nn.Sequential( + nn.SiLU(), + nn.Linear(dim, 6 * dim, bias=True), # For scale, shift, gate for norm1 and norm2 + ) + self.txt_norm1 = nn.LayerNorm(dim, elementwise_affine=False, eps=eps) + # Text doesn't need separate attention - it's handled by img_attn joint computation + self.txt_norm2 = nn.LayerNorm(dim, elementwise_affine=False, eps=eps) + self.txt_mlp = FeedForward(dim=dim, dim_out=dim, activation_fn="gelu-approximate") + + self.zero_cond_t = zero_cond_t + + def _modulate(self, x, mod_params, timestep_zero_index: Optional[int] = None) -> Tuple[torch.Tensor, torch.Tensor]: + """Apply modulation to input tensor""" + # x: [b, l, d], shift/scale/gate: [b, d] (or [2*b, d] when `zero_cond_t=True`) + shift, scale, gate = mod_params.chunk(3, dim=-1) + + if timestep_zero_index is not None: + actual_batch = shift.size(0) // 2 + shift_base, shift_ext = shift[:actual_batch], shift[actual_batch:] + scale_base, scale_ext = scale[:actual_batch], scale[actual_batch:] + gate_base, gate_ext = gate[:actual_batch], gate[actual_batch:] + + shift_base = shift_base.unsqueeze(1) + shift_ext = shift_ext.unsqueeze(1) + scale_base = scale_base.unsqueeze(1) + scale_ext = scale_ext.unsqueeze(1) + gate_base = gate_base.unsqueeze(1) + gate_ext = gate_ext.unsqueeze(1) + + return torch.cat( + [ + x[:, :timestep_zero_index] * (1 + scale_base) + shift_base, + x[:, timestep_zero_index:] * (1 + scale_ext) + shift_ext, + ], + dim=1, + ), torch.cat( + [gate_base.expand(-1, timestep_zero_index, -1), gate_ext.expand(-1, x.size(1) - timestep_zero_index, -1)], dim=1 + ) + else: + shift_result = shift.unsqueeze(1) + scale_result = scale.unsqueeze(1) + gate_result = gate.unsqueeze(1) + return x * (1 + scale_result) + shift_result, gate_result + + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor, + encoder_hidden_states_mask: torch.Tensor, + temb: torch.Tensor, + image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None, + txt_seq_lens: Optional[torch.Tensor] = None, + joint_attention_kwargs: Optional[Dict[str, Any]] = None, + timestep_zero_index: Optional[int] = None, + ) -> Tuple[torch.Tensor, torch.Tensor]: + # Get modulation parameters for both streams + img_mod_params = self.img_mod(temb) # [B, 6*dim] + if self.zero_cond_t: + temb = torch.chunk(temb, 2, dim=0)[0] + txt_mod_params = self.txt_mod(temb) # [B, 6*dim] + + # Split modulation parameters for norm1 and norm2 + img_mod1, img_mod2 = img_mod_params.chunk(2, dim=-1) # Each [B, 3*dim] + del img_mod_params + txt_mod1, txt_mod2 = txt_mod_params.chunk(2, dim=-1) # Each [B, 3*dim] + del txt_mod_params + + # Process image stream - norm1 + modulation + img_normed = self.img_norm1(hidden_states) + img_modulated, img_gate1 = self._modulate(img_normed, img_mod1, timestep_zero_index) + del img_normed, img_mod1 + + # Process text stream - norm1 + modulation + txt_normed = self.txt_norm1(encoder_hidden_states) + txt_modulated, txt_gate1 = self._modulate(txt_normed, txt_mod1) + del txt_normed, txt_mod1 + + # Use QwenAttnProcessor2_0 for joint attention computation + # This directly implements the DoubleStreamLayerMegatron logic: + # 1. Computes QKV for both streams + # 2. Applies QK normalization and RoPE + # 3. Concatenates and runs joint attention + # 4. Splits results back to separate streams + joint_attention_kwargs = joint_attention_kwargs or {} + attn_output = self.attn( + hidden_states=img_modulated, # Image stream (will be processed as "sample") + encoder_hidden_states=txt_modulated, # Text stream (will be processed as "context") + encoder_hidden_states_mask=encoder_hidden_states_mask, + image_rotary_emb=image_rotary_emb, + txt_seq_lens=txt_seq_lens, + **joint_attention_kwargs, + ) + del img_modulated, txt_modulated + + # QwenAttnProcessor2_0 returns (img_output, txt_output) when encoder_hidden_states is provided + img_attn_output, txt_attn_output = attn_output + del attn_output + + # Apply attention gates and add residual (like in Megatron) + hidden_states = torch.addcmul(hidden_states, img_gate1, img_attn_output) + del img_gate1, img_attn_output + encoder_hidden_states = torch.addcmul(encoder_hidden_states, txt_gate1, txt_attn_output) + del txt_gate1, txt_attn_output + + # Process image stream - norm2 + MLP + img_normed2 = self.img_norm2(hidden_states) + img_modulated2, img_gate2 = self._modulate(img_normed2, img_mod2, timestep_zero_index) + del img_normed2, img_mod2 + img_mlp_output = self.img_mlp(img_modulated2) + del img_modulated2 + hidden_states = torch.addcmul(hidden_states, img_gate2, img_mlp_output) + del img_gate2, img_mlp_output + + # Process text stream - norm2 + MLP + txt_normed2 = self.txt_norm2(encoder_hidden_states) + txt_modulated2, txt_gate2 = self._modulate(txt_normed2, txt_mod2) + del txt_normed2, txt_mod2 + txt_mlp_output = self.txt_mlp(txt_modulated2) + del txt_modulated2 + encoder_hidden_states = torch.addcmul(encoder_hidden_states, txt_gate2, txt_mlp_output) + del txt_gate2, txt_mlp_output + + # Clip to prevent overflow for fp16 + if encoder_hidden_states.dtype == torch.float16: + encoder_hidden_states = encoder_hidden_states.clip(-65504, 65504) + if hidden_states.dtype == torch.float16: + hidden_states = hidden_states.clip(-65504, 65504) + + return encoder_hidden_states, hidden_states + + +class QwenImageTransformer2DModel(nn.Module): # ModelMixin, ConfigMixin, PeftAdapterMixin, FromOriginalModelMixin, CacheMixin): + """ + The Transformer model introduced in Qwen. + + Args: + patch_size (`int`, defaults to `2`): + Patch size to turn the input data into small patches. + in_channels (`int`, defaults to `64`): + The number of channels in the input. + out_channels (`int`, *optional*, defaults to `None`): + The number of channels in the output. If not specified, it defaults to `in_channels`. + num_layers (`int`, defaults to `60`): + The number of layers of dual stream DiT blocks to use. + attention_head_dim (`int`, defaults to `128`): + The number of dimensions to use for each attention head. + num_attention_heads (`int`, defaults to `24`): + The number of attention heads to use. + joint_attention_dim (`int`, defaults to `3584`): + The number of dimensions to use for the joint attention (embedding/channel dimension of + `encoder_hidden_states`). + guidance_embeds (`bool`, defaults to `False`): + Whether to use guidance embeddings for guidance-distilled variant of the model. + axes_dims_rope (`Tuple[int]`, defaults to `(16, 56, 56)`): + The dimensions to use for the rotary positional embeddings. + attn_mode (`str`, defaults to `"torch"`): + The attention implementation to use. + split_attn (`bool`, defaults to `False`): + Whether to split the attention computation to save memory. + zero_cond_t (`bool`, defaults to `False`): + Whether to use zero conditioning for time embeddings. + """ + + # _supports_gradient_checkpointing = True + # _no_split_modules = ["QwenImageTransformerBlock"] + # _skip_layerwise_casting_patterns = ["pos_embed", "norm"] + + # @register_to_config + def __init__( + self, + patch_size: int = 2, + in_channels: int = 64, + out_channels: Optional[int] = 16, + num_layers: int = 60, + attention_head_dim: int = 128, + num_attention_heads: int = 24, + joint_attention_dim: int = 3584, + guidance_embeds: bool = False, # TODO: this should probably be removed + axes_dims_rope: Tuple[int, int, int] = (16, 56, 56), + attn_mode: str = "torch", + split_attn: bool = False, + zero_cond_t: bool = False, + use_additional_t_cond: bool = False, + use_layer3d_rope: bool = False, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = out_channels or in_channels + self.inner_dim = num_attention_heads * attention_head_dim + self.attn_mode = attn_mode + self.split_attn = split_attn + + if not use_layer3d_rope: + self.pos_embed = QwenEmbedRope(theta=10000, axes_dim=list(axes_dims_rope), scale_rope=True) + else: + self.pos_embed = QwenEmbedLayer3DRope(theta=10000, axes_dim=list(axes_dims_rope), scale_rope=True) + + self.time_text_embed = QwenTimestepProjEmbeddings(embedding_dim=self.inner_dim, use_additional_t_cond=use_additional_t_cond) + + self.txt_norm = RMSNorm(joint_attention_dim, eps=1e-6) + + self.img_in = nn.Linear(in_channels, self.inner_dim) + self.txt_in = nn.Linear(joint_attention_dim, self.inner_dim) + + self.transformer_blocks = nn.ModuleList( + [ + QwenImageTransformerBlock( + dim=self.inner_dim, + num_attention_heads=num_attention_heads, + attention_head_dim=attention_head_dim, + attn_mode=attn_mode, + split_attn=split_attn, + zero_cond_t=zero_cond_t, + ) + for _ in range(num_layers) + ] + ) + + self.norm_out = AdaLayerNormContinuous(self.inner_dim, self.inner_dim, elementwise_affine=False, eps=1e-6) + self.proj_out = nn.Linear(self.inner_dim, patch_size * patch_size * self.out_channels, bias=True) + + self.gradient_checkpointing = False + self.zero_cond_t = zero_cond_t + self.activation_cpu_offloading = False + + # offloading + self.blocks_to_swap = None + self.offloader = None + + @property + def dtype(self): + return next(self.parameters()).dtype + + @property + def device(self): + return next(self.parameters()).device + + def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False): + self.gradient_checkpointing = True + self.activation_cpu_offloading = activation_cpu_offloading + print(f"QwenModel: Gradient checkpointing enabled. Activation CPU offloading: {activation_cpu_offloading}") + + def disable_gradient_checkpointing(self): + self.gradient_checkpointing = False + self.activation_cpu_offloading = False + print("QwenModel: Gradient checkpointing disabled.") + + def enable_block_swap( + self, blocks_to_swap: int, device: torch.device, supports_backward: bool, use_pinned_memory: bool = False + ): + self.blocks_to_swap = blocks_to_swap + self.num_blocks = len(self.transformer_blocks) + + assert self.blocks_to_swap <= self.num_blocks - 1, ( + f"Cannot swap more than {self.num_blocks - 1} blocks. Requested {self.blocks_to_swap} blocks to swap." + ) + + self.offloader = ModelOffloader( + "qwen-image-block", + self.transformer_blocks, + self.num_blocks, + self.blocks_to_swap, + supports_backward, + device, + use_pinned_memory, + ) + # , debug=True + print( + f"QwenModel: Block swap enabled. Swapping {self.blocks_to_swap} blocks out of {self.num_blocks} blocks. Supports backward: {supports_backward}" + ) + + def switch_block_swap_for_inference(self): + if self.blocks_to_swap: + self.offloader.set_forward_only(True) + self.prepare_block_swap_before_forward() + print("QwenModel: Block swap set to forward only.") + + def switch_block_swap_for_training(self): + if self.blocks_to_swap: + self.offloader.set_forward_only(False) + self.prepare_block_swap_before_forward() + print("QwenModel: Block swap set to forward and backward.") + + def move_to_device_except_swap_blocks(self, device: torch.device): + # assume model is on cpu. do not move blocks to device to reduce temporary memory usage + if self.blocks_to_swap: + save_blocks = self.transformer_blocks + self.transformer_blocks = None + + self.to(device) + + if self.blocks_to_swap: + self.transformer_blocks = save_blocks + + def prepare_block_swap_before_forward(self): + if self.blocks_to_swap is None or self.blocks_to_swap == 0: + return + self.offloader.prepare_block_devices_before_forward(self.transformer_blocks) + + def _gradient_checkpointing_func(self, block, *args): + if self.activation_cpu_offloading: + block = create_cpu_offloading_wrapper(block, self.img_in.weight.device) + return torch.utils.checkpoint.checkpoint(block, *args, use_reentrant=False) + + def forward( + self, + hidden_states: torch.Tensor, + encoder_hidden_states: torch.Tensor = None, + encoder_hidden_states_mask: torch.Tensor = None, + timestep: torch.Tensor = None, + img_shapes: Optional[List[Tuple[int, int, int]]] = None, + txt_seq_lens: Optional[List[int]] = None, + guidance: torch.Tensor = None, # TODO: this should probably be removed + attention_kwargs: Optional[Dict[str, Any]] = None, + additional_t_cond=None, + ) -> torch.Tensor: + """ + The [`QwenTransformer2DModel`] forward method. + + Args: + hidden_states (`torch.Tensor` of shape `(batch_size, image_sequence_length, in_channels)`): + Input `hidden_states`. + encoder_hidden_states (`torch.Tensor` of shape `(batch_size, text_sequence_length, joint_attention_dim)`): + Conditional embeddings (embeddings computed from the input conditions such as prompts) to use. + encoder_hidden_states_mask (`torch.Tensor` of shape `(batch_size, text_sequence_length)`): + Mask of the input conditions. + timestep ( `torch.Tensor`): + Used to indicate denoising step. + attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~models.transformer_2d.Transformer2DModelOutput`] instead of a plain + tuple. + + Returns: + If `return_dict` is True, an [`~models.transformer_2d.Transformer2DModelOutput`] is returned, otherwise a + `tuple` where the first element is the sample tensor. + """ + # if attention_kwargs is not None: + # attention_kwargs = attention_kwargs.copy() + # lora_scale = attention_kwargs.pop("scale", 1.0) + # else: + # lora_scale = 1.0 + + # if USE_PEFT_BACKEND: + # # weight the lora layers by setting `lora_scale` for each PEFT layer + # scale_lora_layers(self, lora_scale) + # else: + # if attention_kwargs is not None and attention_kwargs.get("scale", None) is not None: + # logger.warning( + # "Passing `scale` via `joint_attention_kwargs` when not using the PEFT backend is ineffective." + # ) + if encoder_hidden_states_mask is not None and encoder_hidden_states_mask.dtype != torch.bool: + encoder_hidden_states_mask = encoder_hidden_states_mask.bool() + + hidden_states = self.img_in(hidden_states) + + timestep = timestep.to(hidden_states.dtype) + + if self.zero_cond_t: + if img_shapes is None: + raise ValueError("`img_shapes` must be provided when `zero_cond_t=True`.") + + timestep = torch.cat([timestep, timestep * 0], dim=0) + + sample = img_shapes[0] # img_shapes always has single entry for musubi tuner + if isinstance(sample, (tuple, list)) and len(sample) == 3 and all(isinstance(x, numbers.Integral) for x in sample): + base_len = int(prod(sample)) + else: + if not (isinstance(sample, (tuple, list)) and len(sample) >= 1): + raise ValueError("Invalid `img_shapes` entry for `zero_cond_t=True`.") + base = sample[0] + if not (isinstance(base, (tuple, list)) and len(base) == 3): + raise ValueError("Invalid `img_shapes` entry for `zero_cond_t=True`.") + base_len = int(prod(base)) + timestep_zero_index = base_len + else: + timestep_zero_index = None + + encoder_hidden_states = self.txt_norm(encoder_hidden_states) + encoder_hidden_states = self.txt_in(encoder_hidden_states) + + if guidance is not None: + guidance = guidance.to(hidden_states.dtype) * 1000 + + temb = self.time_text_embed(timestep, hidden_states, additional_t_cond) + + image_rotary_emb = self.pos_embed(img_shapes, txt_seq_lens, device=hidden_states.device) + + # block expects tensor instead of list + txt_seq_lens = torch.tensor(txt_seq_lens, device=hidden_states.device) if txt_seq_lens is not None else None + + input_device = hidden_states.device + for index_block, block in enumerate(self.transformer_blocks): + if self.blocks_to_swap: + self.offloader.wait_for_block(index_block) + + if torch.is_grad_enabled() and self.gradient_checkpointing: + encoder_hidden_states, hidden_states = self._gradient_checkpointing_func( + block, + hidden_states, + encoder_hidden_states, + encoder_hidden_states_mask, + temb, + image_rotary_emb, + txt_seq_lens, + attention_kwargs, + timestep_zero_index, + ) + + else: + encoder_hidden_states, hidden_states = block( + hidden_states=hidden_states, + encoder_hidden_states=encoder_hidden_states, + encoder_hidden_states_mask=encoder_hidden_states_mask, + temb=temb, + image_rotary_emb=image_rotary_emb, + txt_seq_lens=txt_seq_lens, + joint_attention_kwargs=attention_kwargs, + timestep_zero_index=timestep_zero_index, + ) + + if self.blocks_to_swap: + self.offloader.submit_move_blocks_forward(self.transformer_blocks, index_block) + + if input_device != hidden_states.device: + hidden_states = hidden_states.to(input_device) + + if self.zero_cond_t: + temb = temb.chunk(2, dim=0)[0] + + # Use only the image part (hidden_states) from the dual-stream blocks + hidden_states = self.norm_out(hidden_states, temb) + output = self.proj_out(hidden_states) + + # if USE_PEFT_BACKEND: + # # remove `lora_scale` from each PEFT layer + # unscale_lora_layers(self, lora_scale) + + return output + + +FP8_OPTIMIZATION_TARGET_KEYS = ["transformer_blocks"] +# modulation layers are large and block-wise scaling may be effective, so we quantize them +# norm layers and time_text_embed are small and may be sensitive to quantization, so we skip them +FP8_OPTIMIZATION_EXCLUDE_KEYS = [ + "norm", + # "_mod", + "time_text_embed", +] + + +def create_model( + attn_mode: str, + split_attn: bool, + zero_cond_t: bool, + use_additional_t_cond: bool, + use_layer3d_rope: bool, + dtype: Optional[torch.dtype], + num_layers: Optional[int] = 60, +) -> QwenImageTransformer2DModel: + with init_empty_weights(): + logger.info( + f"Creating QwenImageTransformer2DModel. Attn mode: {attn_mode}, split_attn: {split_attn}, zero_cond_t: {zero_cond_t}, num_layers: {num_layers} " + ) + """ + { + "_class_name": "QwenImageTransformer2DModel", + "_diffusers_version": "0.34.0.dev0", + "attention_head_dim": 128, + "axes_dims_rope": [ + 16, + 56, + 56 + ], + "guidance_embeds": false, + "in_channels": 64, + "joint_attention_dim": 3584, + "num_attention_heads": 24, + "num_layers": 60, + "out_channels": 16, + "patch_size": 2, + "pooled_projection_dim": 768 + } + """ + if num_layers is None: + num_layers = 60 + model = QwenImageTransformer2DModel( + patch_size=2, + in_channels=64, + out_channels=16, + num_layers=num_layers, + attention_head_dim=128, + num_attention_heads=24, + joint_attention_dim=3584, + guidance_embeds=False, + axes_dims_rope=(16, 56, 56), + attn_mode=attn_mode, + split_attn=split_attn, + zero_cond_t=zero_cond_t, + use_additional_t_cond=use_additional_t_cond, + use_layer3d_rope=use_layer3d_rope, + ) + if dtype is not None: + model.to(dtype) + return model + + +def load_qwen_image_model( + device: Union[str, torch.device], + dit_path: str, + attn_mode: str, + split_attn: bool, + zero_cond_t: bool, + use_additional_t_cond: bool, + use_layer3d_rope: bool, + loading_device: Union[str, torch.device], + dit_weight_dtype: Optional[torch.dtype], + fp8_scaled: bool = False, + lora_weights_list: Optional[Dict[str, torch.Tensor]] = None, + lora_multipliers: Optional[List[float]] = None, + num_layers: Optional[int] = 60, + disable_numpy_memmap: bool = False, +) -> QwenImageTransformer2DModel: + """ + Load a Qwen-Image model from the specified checkpoint. + + Args: + device (Union[str, torch.device]): Device for optimization or merging + dit_path (str): Path to the DiT model checkpoint. + attn_mode (str): Attention mode to use, e.g., "torch", "flash", etc. + split_attn (bool): Whether to use split attention. + zero_cond_t (bool): Whether the model uses zero conditioning for time embeddings. + use_additional_t_cond (bool): Whether to use additional time conditioning (for layered model). + use_layer3d_rope (bool): Whether to use 3D RoPE (for layered model). + loading_device (Union[str, torch.device]): Device to load the model weights on. + dit_weight_dtype (Optional[torch.dtype]): Data type of the DiT weights. + If None, it will be loaded as is (same as the state_dict) or scaled for fp8. if not None, model weights will be casted to this dtype. + fp8_scaled (bool): Whether to use fp8 scaling for the model weights. + lora_weights_list (Optional[Dict[str, torch.Tensor]]): LoRA weights to apply, if any. + lora_multipliers (Optional[List[float]]): LoRA multipliers for the weights, if any. + num_layers (int): Number of layers in the DiT model. + disable_numpy_memmap (bool): Whether to disable numpy memory mapping when loading weights. + """ + # dit_weight_dtype is None for fp8_scaled + assert (not fp8_scaled and dit_weight_dtype is not None) or (fp8_scaled and dit_weight_dtype is None) + + device = torch.device(device) + loading_device = torch.device(loading_device) + + model = create_model( + attn_mode, split_attn, zero_cond_t, use_additional_t_cond, use_layer3d_rope, dit_weight_dtype, num_layers=num_layers + ) + + # load model weights with dynamic fp8 optimization and LoRA merging if needed + logger.info(f"Loading DiT model from {dit_path}, device={loading_device}") + sd = load_safetensors_with_lora_and_fp8( + model_files=dit_path, + lora_weights_list=lora_weights_list, + lora_multipliers=lora_multipliers, + fp8_optimization=fp8_scaled, + calc_device=device, + move_to_device=(loading_device == device), + dit_weight_dtype=dit_weight_dtype, + target_keys=FP8_OPTIMIZATION_TARGET_KEYS, + exclude_keys=FP8_OPTIMIZATION_EXCLUDE_KEYS, + disable_numpy_memmap=disable_numpy_memmap, + ) + + # remove "model.diffusion_model." + for key in list(sd.keys()): + if key.startswith("model.diffusion_model."): + sd[key[22:]] = sd.pop(key) + + if "__index_timestep_zero__" in sd: # ComfyUI flag for edit-2511 + assert zero_cond_t, "Found __index_timestep_zero__ in state_dict, the model must be '2511' variant." + sd.pop("__index_timestep_zero__") + + if fp8_scaled: + apply_fp8_monkey_patch(model, sd, use_scaled_mm=False) + + if loading_device.type != "cpu": + # make sure all the model weights are on the loading_device + logger.info(f"Moving weights to {loading_device}") + for key in sd.keys(): + sd[key] = sd[key].to(loading_device) + + info = model.load_state_dict(sd, strict=True, assign=True) + logger.info(f"Loaded DiT model from {dit_path}, info={info}") + + return model diff --git a/src/musubi_tuner/qwen_image/qwen_image_modules.py b/src/musubi_tuner/qwen_image/qwen_image_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..0a88c04186cff3e7e7c5fd6e326e91737e626a36 --- /dev/null +++ b/src/musubi_tuner/qwen_image/qwen_image_modules.py @@ -0,0 +1,32 @@ +from torch import nn + +# region activations + + +ACT2CLS = { + "swish": nn.SiLU, + "silu": nn.SiLU, + "mish": nn.Mish, + "gelu": nn.GELU, + "relu": nn.ReLU, +} + + +def get_activation(act_fn: str) -> nn.Module: + """Helper function to get activation function from string. + + Args: + act_fn (str): Name of activation function. + + Returns: + nn.Module: Activation function. + """ + + act_fn = act_fn.lower() + if act_fn in ACT2CLS: + return ACT2CLS[act_fn]() + else: + raise ValueError(f"activation function {act_fn} not found in ACT2FN mapping {list(ACT2CLS.keys())}") + + +# endregion activations diff --git a/src/musubi_tuner/qwen_image/qwen_image_utils.py b/src/musubi_tuner/qwen_image/qwen_image_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..9e39c18be0fa0e82c3248eb3403958a1f7b2f0f8 --- /dev/null +++ b/src/musubi_tuner/qwen_image/qwen_image_utils.py @@ -0,0 +1,1585 @@ +import argparse +import json +import logging +import math +from typing import List, Optional, Tuple, Union + +import numpy as np +import torch +from transformers import Qwen2_5_VLConfig, Qwen2_5_VLForConditionalGeneration, Qwen2Tokenizer, Qwen2VLProcessor +from transformers.image_utils import ImageInput +from accelerate import init_empty_weights +from diffusers.utils.torch_utils import randn_tensor +from PIL import Image + +from musubi_tuner.dataset.image_video_dataset import BucketSelector, ARCHITECTURE_QWEN_IMAGE_EDIT +from musubi_tuner.flux.flux_utils import is_fp8 +from musubi_tuner.qwen_image.qwen_image_autoencoder_kl import AutoencoderKLQwenImage +from musubi_tuner.utils import image_utils +from musubi_tuner.utils.safetensors_utils import load_safetensors, load_split_weights + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +# region constants + +SCHEDULER_BASE_IMAGE_SEQ_LEN = 256 +SCHEDULER_BASE_SHIFT = 0.5 +SCHEDULER_MAX_IMAGE_SEQ_LEN = 8192 +SCHEDULER_MAX_SHIFT = 0.9 + +VAE_SCALE_FACTOR = 8 # Qwen Image uses 8x compression + +# endregion constants + +# region text encoder +QWEN_IMAGE_ID = "Qwen/Qwen-Image" +QWEN_IMAGE_EDIT_ID = "Qwen/Qwen-Image-Edit" + +GENERATION_CONFIG_JSON = """ +{ + "bos_token_id": 151643, + "do_sample": true, + "eos_token_id": [ + 151645, + 151643 + ], + "pad_token_id": 151643, + "repetition_penalty": 1.05, + "temperature": 0.1, + "top_k": 1, + "top_p": 0.001, + "transformers_version": "4.53.1" +} +""" + + +def load_qwen2_5_vl( + ckpt_path: str, + dtype: Optional[torch.dtype], + device: Union[str, torch.device], + disable_mmap: bool = False, + state_dict: Optional[dict] = None, +) -> tuple[Qwen2Tokenizer, Qwen2_5_VLForConditionalGeneration]: + QWEN2_5_VL_CONFIG_JSON = """ +{ + "architectures": [ + "Qwen2_5_VLForConditionalGeneration" + ], + "attention_dropout": 0.0, + "bos_token_id": 151643, + "eos_token_id": 151645, + "hidden_act": "silu", + "hidden_size": 3584, + "image_token_id": 151655, + "initializer_range": 0.02, + "intermediate_size": 18944, + "max_position_embeddings": 128000, + "max_window_layers": 28, + "model_type": "qwen2_5_vl", + "num_attention_heads": 28, + "num_hidden_layers": 28, + "num_key_value_heads": 4, + "rms_norm_eps": 1e-06, + "rope_scaling": { + "mrope_section": [ + 16, + 24, + 24 + ], + "rope_type": "default", + "type": "default" + }, + "rope_theta": 1000000.0, + "sliding_window": 32768, + "text_config": { + "architectures": [ + "Qwen2_5_VLForConditionalGeneration" + ], + "attention_dropout": 0.0, + "bos_token_id": 151643, + "eos_token_id": 151645, + "hidden_act": "silu", + "hidden_size": 3584, + "image_token_id": null, + "initializer_range": 0.02, + "intermediate_size": 18944, + "layer_types": [ + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention", + "full_attention" + ], + "max_position_embeddings": 128000, + "max_window_layers": 28, + "model_type": "qwen2_5_vl_text", + "num_attention_heads": 28, + "num_hidden_layers": 28, + "num_key_value_heads": 4, + "rms_norm_eps": 1e-06, + "rope_scaling": { + "mrope_section": [ + 16, + 24, + 24 + ], + "rope_type": "default", + "type": "default" + }, + "rope_theta": 1000000.0, + "sliding_window": null, + "torch_dtype": "float32", + "use_cache": true, + "use_sliding_window": false, + "video_token_id": null, + "vision_end_token_id": 151653, + "vision_start_token_id": 151652, + "vision_token_id": 151654, + "vocab_size": 152064 + }, + "tie_word_embeddings": false, + "torch_dtype": "bfloat16", + "transformers_version": "4.53.1", + "use_cache": true, + "use_sliding_window": false, + "video_token_id": 151656, + "vision_config": { + "depth": 32, + "fullatt_block_indexes": [ + 7, + 15, + 23, + 31 + ], + "hidden_act": "silu", + "hidden_size": 1280, + "in_channels": 3, + "in_chans": 3, + "initializer_range": 0.02, + "intermediate_size": 3420, + "model_type": "qwen2_5_vl", + "num_heads": 16, + "out_hidden_size": 3584, + "patch_size": 14, + "spatial_merge_size": 2, + "spatial_patch_size": 14, + "temporal_patch_size": 2, + "tokens_per_second": 2, + "torch_dtype": "float32", + "window_size": 112 + }, + "vision_end_token_id": 151653, + "vision_start_token_id": 151652, + "vision_token_id": 151654, + "vocab_size": 152064 +} +""" + config = json.loads(QWEN2_5_VL_CONFIG_JSON) + config = Qwen2_5_VLConfig(**config) + with init_empty_weights(): + qwen2_5_vl = Qwen2_5_VLForConditionalGeneration._from_config(config) + + if state_dict is not None: + sd = state_dict + else: + logger.info(f"Loading state dict from {ckpt_path}") + sd = load_split_weights(ckpt_path, device=str(device), disable_mmap=disable_mmap, dtype=dtype) + + # convert prefixes + for key in list(sd.keys()): + if key.startswith("model."): + new_key = key.replace("model.", "model.language_model.", 1) + elif key.startswith("visual."): + new_key = key.replace("visual.", "model.visual.", 1) + else: + continue + if key not in sd: + logger.warning(f"Key {key} not found in state dict, skipping.") + continue + sd[new_key] = sd.pop(key) + + info = qwen2_5_vl.load_state_dict(sd, strict=True, assign=True) + logger.info(f"Loaded Qwen2.5-VL: {info}") + qwen2_5_vl.to(device) + + if dtype is not None: + if is_fp8(dtype): + org_dtype = torch.bfloat16 # model weight is fp8 in loading, but original dtype is bfloat16 + logger.info(f"prepare Qwen2.5-VL for fp8: set to {dtype} from {org_dtype}") + qwen2_5_vl.to(dtype) + + # prepare LLM for fp8 + def prepare_fp8(vl_model: Qwen2_5_VLForConditionalGeneration, target_dtype): + def forward_hook(module): + def forward(hidden_states): + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + variance = hidden_states.pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + module.variance_epsilon) + # return module.weight.to(input_dtype) * hidden_states.to(input_dtype) + return (module.weight.to(torch.float32) * hidden_states.to(torch.float32)).to(input_dtype) + + return forward + + def decoder_forward_hook(module): + def forward( + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_value: Optional[tuple[torch.Tensor]] = None, + output_attentions: Optional[bool] = False, + use_cache: Optional[bool] = False, + cache_position: Optional[torch.LongTensor] = None, + position_embeddings: Optional[tuple[torch.Tensor, torch.Tensor]] = None, # necessary, but kept here for BC + **kwargs, + ) -> tuple[torch.FloatTensor, Optional[tuple[torch.FloatTensor, torch.FloatTensor]]]: + residual = hidden_states + + hidden_states = module.input_layernorm(hidden_states) + + # Self Attention + hidden_states, self_attn_weights = module.self_attn( + hidden_states=hidden_states, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_value=past_key_value, + output_attentions=output_attentions, + use_cache=use_cache, + cache_position=cache_position, + position_embeddings=position_embeddings, + **kwargs, + ) + input_dtype = hidden_states.dtype + hidden_states = residual.to(torch.float32) + hidden_states.to(torch.float32) + hidden_states = hidden_states.to(input_dtype) + + # Fully Connected + residual = hidden_states + hidden_states = module.post_attention_layernorm(hidden_states) + hidden_states = module.mlp(hidden_states) + hidden_states = residual + hidden_states + + outputs = (hidden_states,) + + if output_attentions: + outputs += (self_attn_weights,) + + return outputs + + return forward + + for module in vl_model.modules(): + if module.__class__.__name__ in ["Embedding"]: + # print("set", module.__class__.__name__, "to", target_dtype) + module.to(target_dtype) + if module.__class__.__name__ in ["Qwen2RMSNorm"]: + # print("set", module.__class__.__name__, "hooks") + module.forward = forward_hook(module) + if module.__class__.__name__ in ["Qwen2_5_VLDecoderLayer"]: + # print("set", module.__class__.__name__, "hooks") + module.forward = decoder_forward_hook(module) + if module.__class__.__name__ in ["Qwen2_5_VisionRotaryEmbedding"]: + # print("set", module.__class__.__name__, "hooks") + module.to(target_dtype) + + prepare_fp8(qwen2_5_vl, org_dtype) + + else: + logger.info(f"Setting Qwen2.5-VL to dtype: {dtype}") + qwen2_5_vl.to(dtype) + + # Load tokenizer + logger.info(f"Loading tokenizer from {QWEN_IMAGE_ID}") + tokenizer = Qwen2Tokenizer.from_pretrained(QWEN_IMAGE_ID, subfolder="tokenizer") + return tokenizer, qwen2_5_vl + + +def load_vl_processor() -> Qwen2VLProcessor: + logger.info(f"Loading VL processor from {QWEN_IMAGE_EDIT_ID}") + return Qwen2VLProcessor.from_pretrained(QWEN_IMAGE_EDIT_ID, subfolder="processor") + + +def extract_masked_hidden(hidden_states: torch.Tensor, mask: torch.Tensor): + bool_mask = mask.bool() + valid_lengths = bool_mask.sum(dim=1) + selected = hidden_states[bool_mask] + split_result = torch.split(selected, valid_lengths.tolist(), dim=0) + + return split_result + + +def get_qwen_prompt_embeds( + tokenizer: Qwen2Tokenizer, vlm: Qwen2_5_VLForConditionalGeneration, prompt: Union[str, List[str]] = None +): + tokenizer_max_length = 1024 + prompt_template_encode = "<|im_start|>system\nDescribe the image by detailing the color, shape, size, texture, quantity, text, spatial relationships of the objects and background:<|im_end|>\n<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n" + prompt_template_encode_start_idx = 34 + # default_sample_size = 128 + + device = vlm.device + dtype = vlm.dtype + + prompt = [prompt] if isinstance(prompt, str) else prompt + + template = prompt_template_encode + drop_idx = prompt_template_encode_start_idx + txt = [template.format(e) for e in prompt] + txt_tokens = tokenizer(txt, max_length=tokenizer_max_length + drop_idx, padding=True, truncation=True, return_tensors="pt").to( + device + ) + + if is_fp8(dtype): + with torch.no_grad(), torch.autocast(device_type=device.type, dtype=torch.bfloat16): + encoder_hidden_states = vlm( + input_ids=txt_tokens.input_ids, attention_mask=txt_tokens.attention_mask, output_hidden_states=True + ) + else: + with torch.no_grad(): + encoder_hidden_states = vlm( + input_ids=txt_tokens.input_ids, attention_mask=txt_tokens.attention_mask, output_hidden_states=True + ) + hidden_states = encoder_hidden_states.hidden_states[-1] + if hidden_states.shape[1] > tokenizer_max_length + drop_idx: + logger.warning(f"Hidden states shape {hidden_states.shape} exceeds max length {tokenizer_max_length + drop_idx}") + + split_hidden_states = extract_masked_hidden(hidden_states, txt_tokens.attention_mask) + split_hidden_states = [e[drop_idx:] for e in split_hidden_states] + attn_mask_list = [torch.ones(e.size(0), dtype=torch.long, device=e.device) for e in split_hidden_states] + max_seq_len = max([e.size(0) for e in split_hidden_states]) + prompt_embeds = torch.stack([torch.cat([u, u.new_zeros(max_seq_len - u.size(0), u.size(1))]) for u in split_hidden_states]) + encoder_attention_mask = torch.stack([torch.cat([u, u.new_zeros(max_seq_len - u.size(0))]) for u in attn_mask_list]) + + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + return prompt_embeds, encoder_attention_mask + + +def get_qwen_prompt_embeds_with_image( + vl_processor: Qwen2VLProcessor, + vlm: Qwen2_5_VLForConditionalGeneration, + prompt: Union[str, List[str]], + image: Union[List[ImageInput], ImageInput] = None, + model_version: str = "edit", +): + r""" + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + image (`PIL.Image.Image`, `np.ndarray`, `torch.Tensor`): + image to be encoded + model_version (`str`, *optional*, defaults to "edit"): + version of the prompt, can be "edit", "edit-2509" or "edit-2511" + """ + if model_version == "edit": + prompt_template_encode = "<|im_start|>system\nDescribe the key features of the input image (color, shape, size, texture, objects, background), then explain how the user's text instruction should alter or modify the image. Generate a new image that meets the user's requirements while maintaining consistency with the original input where appropriate.<|im_end|>\n<|im_start|>user\n<|vision_start|><|image_pad|><|vision_end|>{}<|im_end|>\n<|im_start|>assistant\n" + elif model_version == "edit-2509" or model_version == "edit-2511": + prompt_template_encode = "<|im_start|>system\nDescribe the key features of the input image (color, shape, size, texture, objects, background), then explain how the user's text instruction should alter or modify the image. Generate a new image that meets the user's requirements while maintaining consistency with the original input where appropriate.<|im_end|>\n<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n" + prompt_template_encode_start_idx = 64 + # default_sample_size = 128 + + device = vlm.device + dtype = vlm.dtype + + prompt = [prompt] if isinstance(prompt, str) else prompt + + if isinstance(image, list): + if len(image) == 0: + image = None + else: + if isinstance(image[0], list): + pass # list of list, it's ok + else: + assert len(prompt) == 1, "Image must be a list of list when multiple prompts are provided." + image = [image] # wrap to list of list + + elif image is not None: + image = [[image]] # wrap to list of list, not necessary, but for consistency + + # RGB conversion + if image is not None: + for i in range(len(image)): + for j in range(len(image[i])): + img = image[i][j] + if isinstance(img, np.ndarray): + if img.shape[2] == 4: + img = img[:, :, :3] + image[i][j] = img + elif isinstance(img, Image.Image): + if img.mode == "RGBA": + img = img.convert("RGB") + image[i][j] = img + + assert image is None or len(image) == len(prompt), ( + f"Number of images {len(image) if image is not None else 0} must match number of prompts {len(prompt)} for batch processing" + ) + + base_img_prompts = [""] * len(prompt) + if image is not None: + vl_image_inputs = [] # flat list of images + if model_version == "edit": + for i, img in enumerate(image): + if img is None or len(img) == 0: + logger.warning(f"No image provided for prompt {i}, but version is {model_version}, this may cause issues.") + continue + if len(img) > 1: + logger.warning( + f"Multiple images {len(img)} provided for prompt {i}, but version is {model_version}, 2nd and later images will be ignored." + ) + vl_image_inputs.append(img[0]) + else: + img_prompt_template = "Picture {}: <|vision_start|><|image_pad|><|vision_end|>" + for i, img in enumerate(image): + if img is None or len(img) == 0: + continue + for j in range(len(img)): + base_img_prompts[i] += img_prompt_template.format(j + 1) + vl_image_inputs.extend(img) + else: + vl_image_inputs = None + + template = prompt_template_encode + drop_idx = prompt_template_encode_start_idx + txt = [template.format(base + e) for base, e in zip(base_img_prompts, prompt)] + + model_inputs = vl_processor(text=txt, images=vl_image_inputs, padding=True, return_tensors="pt").to(device) + + if is_fp8(dtype): + with torch.no_grad(), torch.autocast(device_type=device.type, dtype=torch.bfloat16): + encoder_hidden_states = vlm( + input_ids=model_inputs.input_ids, + attention_mask=model_inputs.attention_mask, + pixel_values=model_inputs.pixel_values, + image_grid_thw=model_inputs.image_grid_thw, + output_hidden_states=True, + ) + else: + with torch.no_grad(): + encoder_hidden_states = vlm( + input_ids=model_inputs.input_ids, + attention_mask=model_inputs.attention_mask, + pixel_values=model_inputs.pixel_values if vl_image_inputs is not None else None, + image_grid_thw=model_inputs.image_grid_thw if vl_image_inputs is not None else None, + output_hidden_states=True, + ) + + hidden_states = encoder_hidden_states.hidden_states[-1] + # if hidden_states.shape[1] > tokenizer_max_length + drop_idx: + # logger.warning(f"Hidden states shape {hidden_states.shape} exceeds max length {tokenizer_max_length + drop_idx}") + + split_hidden_states = extract_masked_hidden(hidden_states, model_inputs.attention_mask) + split_hidden_states = [e[drop_idx:] for e in split_hidden_states] + attn_mask_list = [torch.ones(e.size(0), dtype=torch.long, device=e.device) for e in split_hidden_states] + max_seq_len = max([e.size(0) for e in split_hidden_states]) + prompt_embeds = torch.stack([torch.cat([u, u.new_zeros(max_seq_len - u.size(0), u.size(1))]) for u in split_hidden_states]) + encoder_attention_mask = torch.stack([torch.cat([u, u.new_zeros(max_seq_len - u.size(0))]) for u in attn_mask_list]) + + prompt_embeds = prompt_embeds.to(dtype=dtype, device=device) + + return prompt_embeds, encoder_attention_mask + + +def get_image_caption( + vl_processor: Qwen2VLProcessor, + vlm: Qwen2_5_VLForConditionalGeneration, + prompt_image: Union[List[ImageInput], ImageInput] = None, + use_en_prompt: bool = True, +) -> str: + image_caption_prompt_cn = """<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n# 图像标注器\n你是一个专业的图像标注器。请基于输入图像，撰写图注:\n1. +使用自然、描述性的语言撰写图注，不要使用结构化形式或富文本形式。\n2. 通过加入以下内容，丰富图注细节：\n - 对象的属性：如数量、颜色、形状、大小、位置、材质、状态、动作等\n - +对象间的视觉关系：如空间关系、功能关系、动作关系、从属关系、比较关系、因果关系等\n - 环境细节：例如天气、光照、颜色、纹理、气氛等\n - 文字内容：识别图像中清晰可见的文字，不做翻译和解释，用引号在图注中强调\n3. +保持真实性与准确性：\n - 不要使用笼统的描述\n - +描述图像中所有可见的信息，但不要加入没有在图像中出现的内容\n<|vision_start|><|image_pad|><|vision_end|><|im_end|>\n<|im_start|>assistant\n""" + image_caption_prompt_en = """<|im_start|>system\nYou are a helpful assistant.<|im_end|>\n<|im_start|>user\n# Image Annotator\nYou are a professional +image annotator. Please write an image caption based on the input image:\n1. Write the caption using natural, +descriptive language without structured formats or rich text.\n2. Enrich caption details by including: \n - Object +attributes, such as quantity, color, shape, size, material, state, position, actions, and so on\n - Vision Relations +between objects, such as spatial relations, functional relations, possessive relations, attachment relations, action +relations, comparative relations, causal relations, and so on\n - Environmental details, such as weather, lighting, +colors, textures, atmosphere, and so on\n - Identify the text clearly visible in the image, without translation or +explanation, and highlight it in the caption with quotation marks\n3. Maintain authenticity and accuracy:\n - Avoid +generalizations\n - Describe all visible information in the image, while do not add information not explicitly shown in +the image\n<|vision_start|><|image_pad|><|vision_end|><|im_end|>\n<|im_start|>assistant\n""" + + if use_en_prompt: + prompt = image_caption_prompt_en + else: + prompt = image_caption_prompt_cn + + # Remove alpha channel if present + if isinstance(prompt_image, list) and isinstance(prompt_image[0], np.ndarray): + prompt_image = [img[:, :, :3] if img.shape[2] == 4 else img for img in prompt_image] + elif isinstance(prompt_image, np.ndarray): + if prompt_image.shape[2] == 4: + prompt_image = prompt_image[:, :, :3] + + model_inputs = vl_processor( + text=prompt, + images=prompt_image, + padding=True, + return_tensors="pt", + ).to(vlm.device) + generated_ids = vlm.generate(**model_inputs, max_new_tokens=512) + generated_ids_trimmed = [out_ids[len(in_ids) :] for in_ids, out_ids in zip(model_inputs.input_ids, generated_ids)] + output_text = vl_processor.batch_decode(generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] + return output_text.strip() + + +""" +def encode_prompt( + vlm: Qwen2_5_VLForConditionalGeneration, + prompt: Union[str, List[str]], + prompt_embeds: Optional[torch.Tensor] = None, + prompt_embeds_mask: Optional[torch.Tensor] = None, +): + r"" + + Args: + prompt (`str` or `List[str]`, *optional*): + prompt to be encoded + prompt_embeds (`torch.Tensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + "" + # max_sequence_length: int = 1024, + prompt = [prompt] if isinstance(prompt, str) else prompt + batch_size = len(prompt) if prompt_embeds is None else prompt_embeds.shape[0] + + if prompt_embeds is None: + prompt_embeds, prompt_embeds_mask = get_qwen_prompt_embeds(vlm, prompt) + + _, seq_len, _ = prompt_embeds.shape + prompt_embeds = prompt_embeds.view(batch_size, seq_len, -1) + prompt_embeds_mask = prompt_embeds_mask.view(batch_size, seq_len) + + return prompt_embeds, prompt_embeds_mask +""" + +# endregion text encoder + +# region vae and latents + + +# Convert ComfyUI keys to standard keys if necessary +def convert_comfyui_state_dict(sd): + if "conv1.bias" not in sd: + return sd + + # Key mapping from ComfyUI VAE to official VAE, auto-generated by a script + key_map = { + "conv1": "quant_conv", + "conv2": "post_quant_conv", + "decoder.conv1": "decoder.conv_in", + "decoder.head.0": "decoder.norm_out", + "decoder.head.2": "decoder.conv_out", + "decoder.middle.0.residual.0": "decoder.mid_block.resnets.0.norm1", + "decoder.middle.0.residual.2": "decoder.mid_block.resnets.0.conv1", + "decoder.middle.0.residual.3": "decoder.mid_block.resnets.0.norm2", + "decoder.middle.0.residual.6": "decoder.mid_block.resnets.0.conv2", + "decoder.middle.1.norm": "decoder.mid_block.attentions.0.norm", + "decoder.middle.1.proj": "decoder.mid_block.attentions.0.proj", + "decoder.middle.1.to_qkv": "decoder.mid_block.attentions.0.to_qkv", + "decoder.middle.2.residual.0": "decoder.mid_block.resnets.1.norm1", + "decoder.middle.2.residual.2": "decoder.mid_block.resnets.1.conv1", + "decoder.middle.2.residual.3": "decoder.mid_block.resnets.1.norm2", + "decoder.middle.2.residual.6": "decoder.mid_block.resnets.1.conv2", + "decoder.upsamples.0.residual.0": "decoder.up_blocks.0.resnets.0.norm1", + "decoder.upsamples.0.residual.2": "decoder.up_blocks.0.resnets.0.conv1", + "decoder.upsamples.0.residual.3": "decoder.up_blocks.0.resnets.0.norm2", + "decoder.upsamples.0.residual.6": "decoder.up_blocks.0.resnets.0.conv2", + "decoder.upsamples.1.residual.0": "decoder.up_blocks.0.resnets.1.norm1", + "decoder.upsamples.1.residual.2": "decoder.up_blocks.0.resnets.1.conv1", + "decoder.upsamples.1.residual.3": "decoder.up_blocks.0.resnets.1.norm2", + "decoder.upsamples.1.residual.6": "decoder.up_blocks.0.resnets.1.conv2", + "decoder.upsamples.10.residual.0": "decoder.up_blocks.2.resnets.2.norm1", + "decoder.upsamples.10.residual.2": "decoder.up_blocks.2.resnets.2.conv1", + "decoder.upsamples.10.residual.3": "decoder.up_blocks.2.resnets.2.norm2", + "decoder.upsamples.10.residual.6": "decoder.up_blocks.2.resnets.2.conv2", + "decoder.upsamples.11.resample.1": "decoder.up_blocks.2.upsamplers.0.resample.1", + "decoder.upsamples.12.residual.0": "decoder.up_blocks.3.resnets.0.norm1", + "decoder.upsamples.12.residual.2": "decoder.up_blocks.3.resnets.0.conv1", + "decoder.upsamples.12.residual.3": "decoder.up_blocks.3.resnets.0.norm2", + "decoder.upsamples.12.residual.6": "decoder.up_blocks.3.resnets.0.conv2", + "decoder.upsamples.13.residual.0": "decoder.up_blocks.3.resnets.1.norm1", + "decoder.upsamples.13.residual.2": "decoder.up_blocks.3.resnets.1.conv1", + "decoder.upsamples.13.residual.3": "decoder.up_blocks.3.resnets.1.norm2", + "decoder.upsamples.13.residual.6": "decoder.up_blocks.3.resnets.1.conv2", + "decoder.upsamples.14.residual.0": "decoder.up_blocks.3.resnets.2.norm1", + "decoder.upsamples.14.residual.2": "decoder.up_blocks.3.resnets.2.conv1", + "decoder.upsamples.14.residual.3": "decoder.up_blocks.3.resnets.2.norm2", + "decoder.upsamples.14.residual.6": "decoder.up_blocks.3.resnets.2.conv2", + "decoder.upsamples.2.residual.0": "decoder.up_blocks.0.resnets.2.norm1", + "decoder.upsamples.2.residual.2": "decoder.up_blocks.0.resnets.2.conv1", + "decoder.upsamples.2.residual.3": "decoder.up_blocks.0.resnets.2.norm2", + "decoder.upsamples.2.residual.6": "decoder.up_blocks.0.resnets.2.conv2", + "decoder.upsamples.3.resample.1": "decoder.up_blocks.0.upsamplers.0.resample.1", + "decoder.upsamples.3.time_conv": "decoder.up_blocks.0.upsamplers.0.time_conv", + "decoder.upsamples.4.residual.0": "decoder.up_blocks.1.resnets.0.norm1", + "decoder.upsamples.4.residual.2": "decoder.up_blocks.1.resnets.0.conv1", + "decoder.upsamples.4.residual.3": "decoder.up_blocks.1.resnets.0.norm2", + "decoder.upsamples.4.residual.6": "decoder.up_blocks.1.resnets.0.conv2", + "decoder.upsamples.4.shortcut": "decoder.up_blocks.1.resnets.0.conv_shortcut", + "decoder.upsamples.5.residual.0": "decoder.up_blocks.1.resnets.1.norm1", + "decoder.upsamples.5.residual.2": "decoder.up_blocks.1.resnets.1.conv1", + "decoder.upsamples.5.residual.3": "decoder.up_blocks.1.resnets.1.norm2", + "decoder.upsamples.5.residual.6": "decoder.up_blocks.1.resnets.1.conv2", + "decoder.upsamples.6.residual.0": "decoder.up_blocks.1.resnets.2.norm1", + "decoder.upsamples.6.residual.2": "decoder.up_blocks.1.resnets.2.conv1", + "decoder.upsamples.6.residual.3": "decoder.up_blocks.1.resnets.2.norm2", + "decoder.upsamples.6.residual.6": "decoder.up_blocks.1.resnets.2.conv2", + "decoder.upsamples.7.resample.1": "decoder.up_blocks.1.upsamplers.0.resample.1", + "decoder.upsamples.7.time_conv": "decoder.up_blocks.1.upsamplers.0.time_conv", + "decoder.upsamples.8.residual.0": "decoder.up_blocks.2.resnets.0.norm1", + "decoder.upsamples.8.residual.2": "decoder.up_blocks.2.resnets.0.conv1", + "decoder.upsamples.8.residual.3": "decoder.up_blocks.2.resnets.0.norm2", + "decoder.upsamples.8.residual.6": "decoder.up_blocks.2.resnets.0.conv2", + "decoder.upsamples.9.residual.0": "decoder.up_blocks.2.resnets.1.norm1", + "decoder.upsamples.9.residual.2": "decoder.up_blocks.2.resnets.1.conv1", + "decoder.upsamples.9.residual.3": "decoder.up_blocks.2.resnets.1.norm2", + "decoder.upsamples.9.residual.6": "decoder.up_blocks.2.resnets.1.conv2", + "encoder.conv1": "encoder.conv_in", + "encoder.downsamples.0.residual.0": "encoder.down_blocks.0.norm1", + "encoder.downsamples.0.residual.2": "encoder.down_blocks.0.conv1", + "encoder.downsamples.0.residual.3": "encoder.down_blocks.0.norm2", + "encoder.downsamples.0.residual.6": "encoder.down_blocks.0.conv2", + "encoder.downsamples.1.residual.0": "encoder.down_blocks.1.norm1", + "encoder.downsamples.1.residual.2": "encoder.down_blocks.1.conv1", + "encoder.downsamples.1.residual.3": "encoder.down_blocks.1.norm2", + "encoder.downsamples.1.residual.6": "encoder.down_blocks.1.conv2", + "encoder.downsamples.10.residual.0": "encoder.down_blocks.10.norm1", + "encoder.downsamples.10.residual.2": "encoder.down_blocks.10.conv1", + "encoder.downsamples.10.residual.3": "encoder.down_blocks.10.norm2", + "encoder.downsamples.10.residual.6": "encoder.down_blocks.10.conv2", + "encoder.downsamples.2.resample.1": "encoder.down_blocks.2.resample.1", + "encoder.downsamples.3.residual.0": "encoder.down_blocks.3.norm1", + "encoder.downsamples.3.residual.2": "encoder.down_blocks.3.conv1", + "encoder.downsamples.3.residual.3": "encoder.down_blocks.3.norm2", + "encoder.downsamples.3.residual.6": "encoder.down_blocks.3.conv2", + "encoder.downsamples.3.shortcut": "encoder.down_blocks.3.conv_shortcut", + "encoder.downsamples.4.residual.0": "encoder.down_blocks.4.norm1", + "encoder.downsamples.4.residual.2": "encoder.down_blocks.4.conv1", + "encoder.downsamples.4.residual.3": "encoder.down_blocks.4.norm2", + "encoder.downsamples.4.residual.6": "encoder.down_blocks.4.conv2", + "encoder.downsamples.5.resample.1": "encoder.down_blocks.5.resample.1", + "encoder.downsamples.5.time_conv": "encoder.down_blocks.5.time_conv", + "encoder.downsamples.6.residual.0": "encoder.down_blocks.6.norm1", + "encoder.downsamples.6.residual.2": "encoder.down_blocks.6.conv1", + "encoder.downsamples.6.residual.3": "encoder.down_blocks.6.norm2", + "encoder.downsamples.6.residual.6": "encoder.down_blocks.6.conv2", + "encoder.downsamples.6.shortcut": "encoder.down_blocks.6.conv_shortcut", + "encoder.downsamples.7.residual.0": "encoder.down_blocks.7.norm1", + "encoder.downsamples.7.residual.2": "encoder.down_blocks.7.conv1", + "encoder.downsamples.7.residual.3": "encoder.down_blocks.7.norm2", + "encoder.downsamples.7.residual.6": "encoder.down_blocks.7.conv2", + "encoder.downsamples.8.resample.1": "encoder.down_blocks.8.resample.1", + "encoder.downsamples.8.time_conv": "encoder.down_blocks.8.time_conv", + "encoder.downsamples.9.residual.0": "encoder.down_blocks.9.norm1", + "encoder.downsamples.9.residual.2": "encoder.down_blocks.9.conv1", + "encoder.downsamples.9.residual.3": "encoder.down_blocks.9.norm2", + "encoder.downsamples.9.residual.6": "encoder.down_blocks.9.conv2", + "encoder.head.0": "encoder.norm_out", + "encoder.head.2": "encoder.conv_out", + "encoder.middle.0.residual.0": "encoder.mid_block.resnets.0.norm1", + "encoder.middle.0.residual.2": "encoder.mid_block.resnets.0.conv1", + "encoder.middle.0.residual.3": "encoder.mid_block.resnets.0.norm2", + "encoder.middle.0.residual.6": "encoder.mid_block.resnets.0.conv2", + "encoder.middle.1.norm": "encoder.mid_block.attentions.0.norm", + "encoder.middle.1.proj": "encoder.mid_block.attentions.0.proj", + "encoder.middle.1.to_qkv": "encoder.mid_block.attentions.0.to_qkv", + "encoder.middle.2.residual.0": "encoder.mid_block.resnets.1.norm1", + "encoder.middle.2.residual.2": "encoder.mid_block.resnets.1.conv1", + "encoder.middle.2.residual.3": "encoder.mid_block.resnets.1.norm2", + "encoder.middle.2.residual.6": "encoder.mid_block.resnets.1.conv2", + } + + new_state_dict = {} + for key in sd.keys(): + new_key = key + key_without_suffix = key.rsplit(".", 1)[0] + if key_without_suffix in key_map: + new_key = key.replace(key_without_suffix, key_map[key_without_suffix]) + new_state_dict[new_key] = sd[key] + + logger.info("Converted ComfyUI AutoencoderKL state dict keys to official format") + return new_state_dict + + +def load_vae( + vae_path: str, input_channels: int = 3, device: Union[str, torch.device] = "cpu", disable_mmap: bool = False +) -> AutoencoderKLQwenImage: + """Load VAE from a given path.""" + VAE_CONFIG_JSON = """ +{ + "_class_name": "AutoencoderKLQwenImage", + "_diffusers_version": "0.34.0.dev0", + "attn_scales": [], + "base_dim": 96, + "dim_mult": [ + 1, + 2, + 4, + 4 + ], + "dropout": 0.0, + "latents_mean": [ + -0.7571, + -0.7089, + -0.9113, + 0.1075, + -0.1745, + 0.9653, + -0.1517, + 1.5508, + 0.4134, + -0.0715, + 0.5517, + -0.3632, + -0.1922, + -0.9497, + 0.2503, + -0.2921 + ], + "latents_std": [ + 2.8184, + 1.4541, + 2.3275, + 2.6558, + 1.2196, + 1.7708, + 2.6052, + 2.0743, + 3.2687, + 2.1526, + 2.8652, + 1.5579, + 1.6382, + 1.1253, + 2.8251, + 1.916 + ], + "num_res_blocks": 2, + "temperal_downsample": [ + false, + true, + true + ], + "z_dim": 16 +} +""" + logger.info("Initializing VAE") + config = json.loads(VAE_CONFIG_JSON) + vae = AutoencoderKLQwenImage( + base_dim=config["base_dim"], + z_dim=config["z_dim"], + dim_mult=config["dim_mult"], + num_res_blocks=config["num_res_blocks"], + attn_scales=config["attn_scales"], + temperal_downsample=config["temperal_downsample"], + dropout=config["dropout"], + latents_mean=config["latents_mean"], + latents_std=config["latents_std"], + input_channels=input_channels, + ) + + logger.info(f"Loading VAE from {vae_path}") + state_dict = load_safetensors(vae_path, device=device, disable_mmap=disable_mmap) + + # Convert ComfyUI VAE keys to official VAE keys + state_dict = convert_comfyui_state_dict(state_dict) + + info = vae.load_state_dict(state_dict, strict=True, assign=True) + logger.info(f"Loaded VAE: {info}") + + vae.to(device) + return vae + + +def unpack_latents(latents, height, width, vae_scale_factor=VAE_SCALE_FACTOR, is_layered: Optional[bool] = None) -> torch.Tensor: + """ + Returns layered (B, L, C, H, W) or single frame (B, C, 1, H, W) latents from (B, N, C) packed latents, + where L is number of layers, N = (H/2)*(W/2)*L. + If is_layered is None, it will automatically determine whether to return layered or single frame latents based on N and H, W. + """ + batch_size, num_patches, channels = latents.shape + + # VAE applies 8x compression on images but we must also account for packing which requires + # latent height and width to be divisible by 2. + height = 2 * (int(height) // (vae_scale_factor * 2)) + width = 2 * (int(width) // (vae_scale_factor * 2)) + num_layers = num_patches // ((height // 2) * (width // 2)) + + latents = latents.view(batch_size, num_layers, height // 2, width // 2, channels // 4, 2, 2) + latents = latents.permute(0, 1, 4, 2, 5, 3, 6) + latents = latents.reshape(batch_size, num_layers, channels // (2 * 2), height, width) + if num_layers == 1 and is_layered is not True: + latents = latents.permute(0, 2, 1, 3, 4) # (B, C, 1, H, W) + return latents + + +# not used in the current implementation, but kept for reference +# def prepare_latent_image_ids(batch_size, height, width, device, dtype): +# latent_image_ids = torch.zeros(height, width, 3) +# latent_image_ids[..., 1] = latent_image_ids[..., 1] + torch.arange(height)[:, None] +# latent_image_ids[..., 2] = latent_image_ids[..., 2] + torch.arange(width)[None, :] +# latent_image_id_height, latent_image_id_width, latent_image_id_channels = latent_image_ids.shape +# latent_image_ids = latent_image_ids.reshape(latent_image_id_height * latent_image_id_width, latent_image_id_channels) +# return latent_image_ids.to(device=device, dtype=dtype) + + +def pack_latents(latents: torch.Tensor) -> torch.Tensor: + """ + This function handles layered (B, L, C, H, W), single frame (B, C, 1, H, W) and normal (B, C, H, W) latents. So the logic is a bit weird. + If latents have 4 dimensions or the 3rd dimension is 1, it assumes it's single frame or normal latents. + It packs the latents into a shape of (B, H/2, W/2, C, 2, 2) and then reshapes it to (B, H/2 * W/2, C*4) = (B, Seq, In-Channels) + If latents have 5 dimensions and the 3rd dimension is not 1, it assumes it's layered latents. + It packs the latents into a shape of (B, L, H/2, W/2, C, 2, 2) and then reshapes it to (B, L * H/2 * W/2, C*4) = (B, Seq, In-Channels) + """ + batch_size = latents.shape[0] + if latents.ndim == 4 or latents.shape[2] == 1: + # single frame or normal latents + num_channels_latents = latents.shape[1] + height = latents.shape[-2] + width = latents.shape[-1] + + latents = latents.view(batch_size, num_channels_latents, height // 2, 2, width // 2, 2) + latents = latents.permute(0, 2, 4, 1, 3, 5) + latents = latents.reshape(batch_size, (height // 2) * (width // 2), num_channels_latents * 4) + else: + # layered latents: if num_layers == 1, it's equivalent to single frame latents + num_layers = latents.shape[1] + num_channels_latents = latents.shape[2] + height = latents.shape[-2] + width = latents.shape[-1] + + latents = latents.view(batch_size, num_layers, num_channels_latents, height // 2, 2, width // 2, 2) + latents = latents.permute(0, 1, 3, 5, 2, 4, 6) + latents = latents.reshape(batch_size, num_layers * (height // 2) * (width // 2), num_channels_latents * 4) + + return latents + + +def prepare_latents(batch_size, num_layers, num_channels_latents, height, width, dtype, device, generator): + # VAE applies 8x compression on images but we must also account for packing which requires + # latent height and width to be divisible by 2. + vae_scale_factor = VAE_SCALE_FACTOR + height = 2 * (int(height) // (vae_scale_factor * 2)) + width = 2 * (int(width) // (vae_scale_factor * 2)) + + shape = (batch_size, num_layers, num_channels_latents, height, width) + + if isinstance(generator, list) and len(generator) != batch_size: + raise ValueError( + f"You have passed a list of generators of length {len(generator)}, but requested an effective batch" + f" size of {batch_size}. Make sure the batch size matches the length of the generators." + ) + + latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype) + latents = pack_latents(latents) + return latents + + +CONDITION_IMAGE_RESOLUTION = (384, 384) +VAE_IMAGE_RESOLUTION = (1024, 1024) + + +def preprocess_control_image( + control_image_path: str, resize_to_prefered: bool = True, resize_size: Optional[Tuple[int, int]] = None +) -> tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]: + """ + Preprocess the control image for the model. See `preprocess_image` for details. + + Args: + control_image_path (str): Path to the control image. + resize_to_prefered (bool): Whether to resize the image to the preferred resolution (based on the model's requirements). + resize_size (Optional[Tuple[int, int]]): Override target size for resizing if resize_to_prefered is False, with (width, height). + + Returns: + Tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]: A tuple containing: + - control_image_tensor (torch.Tensor): The preprocessed control image tensor for the model. NCHW format. + - control_image_np (np.ndarray): The preprocessed control image as a NumPy array for conditioning. HWC format. + - None: Placeholder for compatibility (no additional data returned). + """ + # See: + # https://github.com/huggingface/diffusers/pull/12188 + # https://github.com/huggingface/diffusers/pull/12190 + + control_image = Image.open(control_image_path) + + if resize_to_prefered or resize_size is None: + resolution = VAE_IMAGE_RESOLUTION if resize_to_prefered else control_image.size + resize_size = BucketSelector.calculate_bucket_resolution( + control_image.size, resolution, architecture=ARCHITECTURE_QWEN_IMAGE_EDIT + ) + + cond_resolution = CONDITION_IMAGE_RESOLUTION if resize_to_prefered else control_image.size + cond_resize_size = BucketSelector.calculate_bucket_resolution( + control_image.size, cond_resolution, architecture=ARCHITECTURE_QWEN_IMAGE_EDIT + ) + else: + cond_resize_size = resize_size + + control_image_tensor, _, _ = image_utils.preprocess_image(control_image, *resize_size, handle_alpha=True) + _, control_image_np, _ = image_utils.preprocess_image(control_image, *cond_resize_size, handle_alpha=True) + return control_image_tensor, control_image_np, None + + +# endregion vae and latents + +# region scheduler + + +def calculate_shift_qwen_image( + image_seq_len: int, + base_seq_len: int = SCHEDULER_BASE_IMAGE_SEQ_LEN, + max_seq_len: int = SCHEDULER_MAX_IMAGE_SEQ_LEN, + base_shift: float = SCHEDULER_BASE_SHIFT, + max_shift: float = SCHEDULER_MAX_SHIFT, +) -> float: + return calculate_shift( + image_seq_len, base_seq_len=base_seq_len, max_seq_len=max_seq_len, base_shift=base_shift, max_shift=max_shift + ) + + +def calculate_shift( + image_seq_len: int, base_seq_len: int = 256, max_seq_len: int = 4096, base_shift: float = 0.5, max_shift: float = 1.15 +) -> float: + m = (max_shift - base_shift) / (max_seq_len - base_seq_len) + b = base_shift - m * base_seq_len + mu = image_seq_len * m + b + return mu + + +# Following code is minimal implementation of retrieve_timesteps +# def retrieve_timesteps( +# sigmas: np.ndarray, device: torch.device, mu: Optional[float] = None, shift: Optional[float] = None +# ) -> tuple[np.ndarray, int]: +# # Copy from FlowMatchDiscreteScheduler in Diffusers +# def _time_shift_exponential(mu, sigma, t): +# return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma) +# def _time_shift_linear(mu, sigma, t): +# return mu / (mu + (1 / t - 1) ** sigma) +# if mu is not None: +# sigmas = _time_shift_exponential(mu, 1.0, sigmas) +# elif shift is not None: +# sigmas = _time_shift_linear(shift, 1.0, sigmas) +# else: +# pass # sigmas is already in the correct form +# sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32, device=device) +# timesteps = sigmas * 1000 # num_train_timesteps +# return timesteps, len(timesteps) + + +# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps +def retrieve_timesteps( + scheduler, + num_inference_steps: Optional[int] = None, + device: Optional[Union[str, torch.device]] = None, + timesteps: Optional[List[int]] = None, + sigmas: Optional[List[float]] = None, + **kwargs, +): + r""" + Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles + custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`. + + Args: + scheduler (`SchedulerMixin`): + The scheduler to get timesteps from. + num_inference_steps (`int`): + The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps` + must be `None`. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + timesteps (`List[int]`, *optional*): + Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed, + `num_inference_steps` and `sigmas` must be `None`. + sigmas (`List[float]`, *optional*): + Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed, + `num_inference_steps` and `timesteps` must be `None`. + + Returns: + `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the + second element is the number of inference steps. + """ + if timesteps is not None and sigmas is not None: + raise ValueError("Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values") + if timesteps is not None: + # accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + accepts_timesteps = True + if not accepts_timesteps: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" timestep schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + elif sigmas is not None: + # accept_sigmas = "sigmas" in set(inspect.signature(scheduler.set_timesteps).parameters.keys()) + accept_sigmas = True + if not accept_sigmas: + raise ValueError( + f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom" + f" sigmas schedules. Please check whether you are using the correct scheduler." + ) + scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs) + timesteps = scheduler.timesteps + num_inference_steps = len(timesteps) + else: + scheduler.set_timesteps(num_inference_steps, device=device, **kwargs) + timesteps = scheduler.timesteps + return timesteps, num_inference_steps + + +# Copy from diffusers.schedulers.scheduling_flow_match_discrete.FlowMatchDiscreteScheduler + + +class FlowMatchEulerDiscreteScheduler: # SchedulerMixin, ConfigMixin): + """ + Euler scheduler. + + This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic + methods the library implements for all schedulers such as loading and saving. + + Args: + num_train_timesteps (`int`, defaults to 1000): + The number of diffusion steps to train the model. + shift (`float`, defaults to 1.0): + The shift value for the timestep schedule. + use_dynamic_shifting (`bool`, defaults to False): + Whether to apply timestep shifting on-the-fly based on the image resolution. + base_shift (`float`, defaults to 0.5): + Value to stabilize image generation. Increasing `base_shift` reduces variation and image is more consistent + with desired output. + max_shift (`float`, defaults to 1.15): + Value change allowed to latent vectors. Increasing `max_shift` encourages more variation and image may be + more exaggerated or stylized. + base_image_seq_len (`int`, defaults to 256): + The base image sequence length. + max_image_seq_len (`int`, defaults to 4096): + The maximum image sequence length. + invert_sigmas (`bool`, defaults to False): + Whether to invert the sigmas. + shift_terminal (`float`, defaults to None): + The end value of the shifted timestep schedule. + use_karras_sigmas (`bool`, defaults to False): + Whether to use Karras sigmas for step sizes in the noise schedule during sampling. + use_exponential_sigmas (`bool`, defaults to False): + Whether to use exponential sigmas for step sizes in the noise schedule during sampling. + use_beta_sigmas (`bool`, defaults to False): + Whether to use beta sigmas for step sizes in the noise schedule during sampling. + time_shift_type (`str`, defaults to "exponential"): + The type of dynamic resolution-dependent timestep shifting to apply. Either "exponential" or "linear". + stochastic_sampling (`bool`, defaults to False): + Whether to use stochastic sampling. + """ + + _compatibles = [] + order = 1 + + # @register_to_config + def __init__( + self, + num_train_timesteps: int = 1000, + shift: float = 1.0, + use_dynamic_shifting: bool = False, + base_shift: Optional[float] = 0.5, + max_shift: Optional[float] = 1.15, + base_image_seq_len: Optional[int] = 256, + max_image_seq_len: Optional[int] = 4096, + invert_sigmas: bool = False, + shift_terminal: Optional[float] = None, + use_karras_sigmas: Optional[bool] = False, + use_exponential_sigmas: Optional[bool] = False, + use_beta_sigmas: Optional[bool] = False, + time_shift_type: str = "exponential", + stochastic_sampling: bool = False, + ): + assert not use_beta_sigmas, "Beta sigmas are not supported in this minimal implementation." + assert not use_karras_sigmas, "Karras sigmas are not supported in this minimal implementation." + assert not use_exponential_sigmas, "Exponential sigmas are not supported in this minimal implementation." + if time_shift_type not in {"exponential", "linear"}: + raise ValueError("`time_shift_type` must either be 'exponential' or 'linear'.") + + self.num_train_timesteps = num_train_timesteps + self.use_dynamic_shifting = use_dynamic_shifting + self.base_shift = base_shift + self.max_shift = max_shift + self.base_image_seq_len = base_image_seq_len + self.max_image_seq_len = max_image_seq_len + self.invert_sigmas = invert_sigmas + self.shift_terminal = shift_terminal + self.use_karras_sigmas = use_karras_sigmas + self.use_exponential_sigmas = use_exponential_sigmas + self.use_beta_sigmas = use_beta_sigmas + self.time_shift_type = time_shift_type + self.stochastic_sampling = stochastic_sampling + + timesteps = np.linspace(1, num_train_timesteps, num_train_timesteps, dtype=np.float32)[::-1].copy() + timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32) + + sigmas = timesteps / num_train_timesteps + if not use_dynamic_shifting: + # when use_dynamic_shifting is True, we apply the timestep shifting on the fly based on the image resolution + sigmas = shift * sigmas / (1 + (shift - 1) * sigmas) + + self.timesteps = sigmas * num_train_timesteps + + self._step_index = None + self._begin_index = None + + self._shift = shift + + self.sigmas = sigmas.to("cpu") # to avoid too much CPU/GPU communication + self.sigma_min = self.sigmas[-1].item() + self.sigma_max = self.sigmas[0].item() + + @property + def shift(self): + """ + The value used for shifting. + """ + return self._shift + + @property + def step_index(self): + """ + The index counter for current timestep. It will increase 1 after each scheduler step. + """ + return self._step_index + + @property + def begin_index(self): + """ + The index for the first timestep. It should be set from pipeline with `set_begin_index` method. + """ + return self._begin_index + + # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index + def set_begin_index(self, begin_index: int = 0): + """ + Sets the begin index for the scheduler. This function should be run from pipeline before the inference. + + Args: + begin_index (`int`): + The begin index for the scheduler. + """ + self._begin_index = begin_index + + def set_shift(self, shift: float): + self._shift = shift + + def scale_noise( + self, + sample: torch.FloatTensor, + timestep: Union[float, torch.FloatTensor], + noise: Optional[torch.FloatTensor] = None, + ) -> torch.FloatTensor: + """ + Forward process in flow-matching + + Args: + sample (`torch.FloatTensor`): + The input sample. + timestep (`int`, *optional*): + The current timestep in the diffusion chain. + + Returns: + `torch.FloatTensor`: + A scaled input sample. + """ + # Make sure sigmas and timesteps have the same device and dtype as original_samples + sigmas = self.sigmas.to(device=sample.device, dtype=sample.dtype) + + if sample.device.type == "mps" and torch.is_floating_point(timestep): + # mps does not support float64 + schedule_timesteps = self.timesteps.to(sample.device, dtype=torch.float32) + timestep = timestep.to(sample.device, dtype=torch.float32) + else: + schedule_timesteps = self.timesteps.to(sample.device) + timestep = timestep.to(sample.device) + + # self.begin_index is None when scheduler is used for training, or pipeline does not implement set_begin_index + if self.begin_index is None: + step_indices = [self.index_for_timestep(t, schedule_timesteps) for t in timestep] + elif self.step_index is not None: + # add_noise is called after first denoising step (for inpainting) + step_indices = [self.step_index] * timestep.shape[0] + else: + # add noise is called before first denoising step to create initial latent(img2img) + step_indices = [self.begin_index] * timestep.shape[0] + + sigma = sigmas[step_indices].flatten() + while len(sigma.shape) < len(sample.shape): + sigma = sigma.unsqueeze(-1) + + sample = sigma * noise + (1.0 - sigma) * sample + + return sample + + def _sigma_to_t(self, sigma): + return sigma * self.num_train_timesteps + + def time_shift(self, mu: float, sigma: float, t: torch.Tensor): + if self.time_shift_type == "exponential": + return self._time_shift_exponential(mu, sigma, t) + elif self.time_shift_type == "linear": + return self._time_shift_linear(mu, sigma, t) + + def stretch_shift_to_terminal(self, t: torch.Tensor) -> torch.Tensor: + r""" + Stretches and shifts the timestep schedule to ensure it terminates at the configured `shift_terminal` config + value. + + Reference: + https://github.com/Lightricks/LTX-Video/blob/a01a171f8fe3d99dce2728d60a73fecf4d4238ae/ltx_video/schedulers/rf.py#L51 + + Args: + t (`torch.Tensor`): + A tensor of timesteps to be stretched and shifted. + + Returns: + `torch.Tensor`: + A tensor of adjusted timesteps such that the final value equals `self.shift_terminal`. + """ + one_minus_z = 1 - t + scale_factor = one_minus_z[-1] / (1 - self.shift_terminal) + stretched_t = 1 - (one_minus_z / scale_factor) + return stretched_t + + def set_timesteps( + self, + num_inference_steps: Optional[int] = None, + device: Union[str, torch.device] = None, + sigmas: Optional[List[float]] = None, + mu: Optional[float] = None, + timesteps: Optional[List[float]] = None, + ): + """ + Sets the discrete timesteps used for the diffusion chain (to be run before inference). + + Args: + num_inference_steps (`int`, *optional*): + The number of diffusion steps used when generating samples with a pre-trained model. + device (`str` or `torch.device`, *optional*): + The device to which the timesteps should be moved to. If `None`, the timesteps are not moved. + sigmas (`List[float]`, *optional*): + Custom values for sigmas to be used for each diffusion step. If `None`, the sigmas are computed + automatically. + mu (`float`, *optional*): + Determines the amount of shifting applied to sigmas when performing resolution-dependent timestep + shifting. + timesteps (`List[float]`, *optional*): + Custom values for timesteps to be used for each diffusion step. If `None`, the timesteps are computed + automatically. + """ + if self.use_dynamic_shifting and mu is None: + raise ValueError("`mu` must be passed when `use_dynamic_shifting` is set to be `True`") + + if sigmas is not None and timesteps is not None: + if len(sigmas) != len(timesteps): + raise ValueError("`sigmas` and `timesteps` should have the same length") + + if num_inference_steps is not None: + if (sigmas is not None and len(sigmas) != num_inference_steps) or ( + timesteps is not None and len(timesteps) != num_inference_steps + ): + raise ValueError( + "`sigmas` and `timesteps` should have the same length as num_inference_steps, if `num_inference_steps` is provided" + ) + else: + num_inference_steps = len(sigmas) if sigmas is not None else len(timesteps) + + self.num_inference_steps = num_inference_steps + + # 1. Prepare default sigmas + is_timesteps_provided = timesteps is not None + + if is_timesteps_provided: + timesteps = np.array(timesteps).astype(np.float32) + + if sigmas is None: + if timesteps is None: + timesteps = np.linspace(self._sigma_to_t(self.sigma_max), self._sigma_to_t(self.sigma_min), num_inference_steps) + sigmas = timesteps / self.num_train_timesteps + else: + sigmas = np.array(sigmas).astype(np.float32) + num_inference_steps = len(sigmas) + + # 2. Perform timestep shifting. Either no shifting is applied, or resolution-dependent shifting of + # "exponential" or "linear" type is applied + if self.use_dynamic_shifting: + sigmas = self.time_shift(mu, 1.0, sigmas) + else: + sigmas = self.shift * sigmas / (1 + (self.shift - 1) * sigmas) + + # 3. If required, stretch the sigmas schedule to terminate at the configured `shift_terminal` value + if self.shift_terminal: + sigmas = self.stretch_shift_to_terminal(sigmas) + + # # 4. If required, convert sigmas to one of karras, exponential, or beta sigma schedules + # if self.use_karras_sigmas: + # sigmas = self._convert_to_karras(in_sigmas=sigmas, num_inference_steps=num_inference_steps) + # elif self.use_exponential_sigmas: + # sigmas = self._convert_to_exponential(in_sigmas=sigmas, num_inference_steps=num_inference_steps) + # elif self.use_beta_sigmas: + # sigmas = self._convert_to_beta(in_sigmas=sigmas, num_inference_steps=num_inference_steps) + + # 5. Convert sigmas and timesteps to tensors and move to specified device + sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32, device=device) + if not is_timesteps_provided: + timesteps = sigmas * self.num_train_timesteps + else: + timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32, device=device) + + # 6. Append the terminal sigma value. + # If a model requires inverted sigma schedule for denoising but timesteps without inversion, the + # `invert_sigmas` flag can be set to `True`. This case is only required in Mochi + if self.invert_sigmas: + sigmas = 1.0 - sigmas + timesteps = sigmas * self.num_train_timesteps + sigmas = torch.cat([sigmas, torch.ones(1, device=sigmas.device)]) + else: + sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)]) + + self.timesteps = timesteps + self.sigmas = sigmas + self._step_index = None + self._begin_index = None + + def index_for_timestep(self, timestep, schedule_timesteps=None): + if schedule_timesteps is None: + schedule_timesteps = self.timesteps + + indices = (schedule_timesteps == timestep).nonzero() + + # The sigma index that is taken for the **very** first `step` + # is always the second index (or the last index if there is only 1) + # This way we can ensure we don't accidentally skip a sigma in + # case we start in the middle of the denoising schedule (e.g. for image-to-image) + pos = 1 if len(indices) > 1 else 0 + + return indices[pos].item() + + def _init_step_index(self, timestep): + if self.begin_index is None: + if isinstance(timestep, torch.Tensor): + timestep = timestep.to(self.timesteps.device) + self._step_index = self.index_for_timestep(timestep) + else: + self._step_index = self._begin_index + + def step( + self, + model_output: torch.FloatTensor, + timestep: Union[float, torch.FloatTensor], + sample: torch.FloatTensor, + s_churn: float = 0.0, + s_tmin: float = 0.0, + s_tmax: float = float("inf"), + s_noise: float = 1.0, + generator: Optional[torch.Generator] = None, + per_token_timesteps: Optional[torch.Tensor] = None, + return_dict: bool = True, + ) -> Tuple: + """ + Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion + process from the learned model outputs (most often the predicted noise). + + Args: + model_output (`torch.FloatTensor`): + The direct output from learned diffusion model. + timestep (`float`): + The current discrete timestep in the diffusion chain. + sample (`torch.FloatTensor`): + A current instance of a sample created by the diffusion process. + s_churn (`float`): + s_tmin (`float`): + s_tmax (`float`): + s_noise (`float`, defaults to 1.0): + Scaling factor for noise added to the sample. + generator (`torch.Generator`, *optional*): + A random number generator. + per_token_timesteps (`torch.Tensor`, *optional*): + The timesteps for each token in the sample. + return_dict (`bool`): + Whether or not to return a + [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] or tuple. + + Returns: + [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] or `tuple`: + If return_dict is `True`, + [`~schedulers.scheduling_flow_match_euler_discrete.FlowMatchEulerDiscreteSchedulerOutput`] is returned, + otherwise a tuple is returned where the first element is the sample tensor. + """ + + if isinstance(timestep, int) or isinstance(timestep, torch.IntTensor) or isinstance(timestep, torch.LongTensor): + raise ValueError( + ( + "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to" + " `FlowMatchEulerDiscreteScheduler.step()` is not supported. Make sure to pass" + " one of the `scheduler.timesteps` as a timestep." + ), + ) + + if self.step_index is None: + self._init_step_index(timestep) + + # Upcast to avoid precision issues when computing prev_sample + sample = sample.to(torch.float32) + + if per_token_timesteps is not None: + per_token_sigmas = per_token_timesteps / self.num_train_timesteps + + sigmas = self.sigmas[:, None, None] + lower_mask = sigmas < per_token_sigmas[None] - 1e-6 + lower_sigmas = lower_mask * sigmas + lower_sigmas, _ = lower_sigmas.max(dim=0) + + current_sigma = per_token_sigmas[..., None] + next_sigma = lower_sigmas[..., None] + dt = current_sigma - next_sigma + else: + sigma_idx = self.step_index + sigma = self.sigmas[sigma_idx] + sigma_next = self.sigmas[sigma_idx + 1] + + current_sigma = sigma + next_sigma = sigma_next + dt = sigma_next - sigma + + if self.stochastic_sampling: + x0 = sample - current_sigma * model_output + noise = torch.randn_like(sample) + prev_sample = (1.0 - next_sigma) * x0 + next_sigma * noise + else: + prev_sample = sample + dt * model_output + + # upon completion increase step index by one + self._step_index += 1 + if per_token_timesteps is None: + # Cast sample back to model compatible dtype + prev_sample = prev_sample.to(model_output.dtype) + + # if not return_dict: + return (prev_sample,) + + # return FlowMatchEulerDiscreteSchedulerOutput(prev_sample=prev_sample) + + def _time_shift_exponential(self, mu, sigma, t): + return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma) + + def _time_shift_linear(self, mu, sigma, t): + return mu / (mu + (1 / t - 1) ** sigma) + + def __len__(self): + return self.num_train_timesteps + + +def get_scheduler(shift: Optional[float] = None) -> FlowMatchEulerDiscreteScheduler: + SCHEDULER_CONFIG_JSON = """ +{ + "_class_name": "FlowMatchEulerDiscreteScheduler", + "_diffusers_version": "0.34.0.dev0", + "base_image_seq_len": 256, + "base_shift": 0.5, + "invert_sigmas": false, + "max_image_seq_len": 8192, + "max_shift": 0.9, + "num_train_timesteps": 1000, + "shift": 1.0, + "shift_terminal": 0.02, + "stochastic_sampling": false, + "time_shift_type": "exponential", + "use_beta_sigmas": false, + "use_dynamic_shifting": true, + "use_exponential_sigmas": false, + "use_karras_sigmas": false +} +""" + config = json.loads(SCHEDULER_CONFIG_JSON) + + scheduler = FlowMatchEulerDiscreteScheduler( + config["num_train_timesteps"], + shift=config["shift"] if shift is None else shift, + # use_dynamic_shifting=config["use_dynamic_shifting"], + use_dynamic_shifting=True if shift is None else False, + base_shift=config["base_shift"], + max_shift=config["max_shift"], + base_image_seq_len=config["base_image_seq_len"], + max_image_seq_len=config["max_image_seq_len"], + invert_sigmas=config["invert_sigmas"], + shift_terminal=config["shift_terminal"], + stochastic_sampling=config["stochastic_sampling"], + time_shift_type="exponential" if shift is None else "linear", + use_beta_sigmas=config["use_beta_sigmas"], + use_exponential_sigmas=config["use_exponential_sigmas"], + use_karras_sigmas=config["use_karras_sigmas"], + ) + return scheduler + + +# endregion scheduler + +# region model utils + + +def add_model_version_args(parser: argparse.ArgumentParser): + parser.add_argument( + "--edit", action="store_true", help="Enable Qwen-Image-Edit original, recommend `--model_version edit` instead" + ) + parser.add_argument( + "--edit_plus", action="store_true", help="Enable Qwen-Image-Edit-2509 (plus), recommend `--model_version edit-2509` instead" + ) + parser.add_argument( + "--model_version", + type=str, + default=None, + help="training for Qwen-Image model version, e.g., 'original', 'layered', 'edit', 'edit-2509', 'edit-2511' etc.", + ) + + +def resolve_model_version_args(args: argparse.Namespace) -> str: + if args.model_version is not None: + args.model_version = args.model_version.lower() + elif getattr(args, "edit_plus", False): + args.model_version = "edit-2509" + elif getattr(args, "edit", False): + args.model_version = "edit" + else: + args.model_version = "original" # Not specified, use original (non-edit) model + + valid_model_versions = {"original", "layered", "edit", "edit-2509", "edit-2511"} + if args.model_version not in valid_model_versions: + valid_str = "', '".join(sorted(valid_model_versions)) + raise ValueError(f"Invalid model_version '{args.model_version}'. Valid options are: '{valid_str}'.") + + args.is_edit = args.model_version in {"edit", "edit-2509", "edit-2511"} + args.is_layered = args.model_version == "layered" + return args.model_version + + +# endregion model utils diff --git a/src/musubi_tuner/utils/__init__.py b/src/musubi_tuner/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/src/musubi_tuner/utils/device_utils.py b/src/musubi_tuner/utils/device_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..479808846adafa8230906000e974b863aa5b731c --- /dev/null +++ b/src/musubi_tuner/utils/device_utils.py @@ -0,0 +1,28 @@ +from typing import Optional, Union +import torch + + +def clean_memory_on_device(device: Optional[Union[str, torch.device]]): + if device is None: + return + if isinstance(device, str): + device = torch.device(device) + if device.type == "cuda": + torch.cuda.empty_cache() + elif device.type == "cpu": + pass + elif device.type == "mps": # not tested + torch.mps.empty_cache() + + +def synchronize_device(device: Optional[Union[str, torch.device]]): + if device is None: + return + if isinstance(device, str): + device = torch.device(device) + if device.type == "cuda": + torch.cuda.synchronize() + elif device.type == "xpu": + torch.xpu.synchronize() + elif device.type == "mps": + torch.mps.synchronize() diff --git a/src/musubi_tuner/utils/image_utils.py b/src/musubi_tuner/utils/image_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..ec872b3b4cbdf7392dc65c33bf4de83ca0b01fa7 --- /dev/null +++ b/src/musubi_tuner/utils/image_utils.py @@ -0,0 +1,40 @@ +import numpy as np +import torch +from PIL import Image +from typing import Tuple, Optional + +from musubi_tuner.dataset import image_video_dataset + + +# prepare image +def preprocess_image( + image: Image, w: int, h: int, handle_alpha: bool = False +) -> Tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]: + """ + Preprocess the image for the model. + Args: + image (Image): The input image. RGB or RGBA format. + w (int): The target bucket width. + h (int): The target bucket height. + handle_alpha (bool): Whether to handle alpha channel for tensor and numpy array. + Returns: + Tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]: + - image_tensor: The preprocessed image tensor (NCHW format). -1.0 to 1.0. + - image_np: The original image as a numpy array (HWC format). 0 to 255. + - alpha: The alpha channel of the image if present in original size, otherwise None. + """ + if image.mode == "RGBA": + alpha = image.split()[-1] + else: + alpha = None + if handle_alpha: + image = image.convert("RGBA") + else: + image = image.convert("RGB") + + image_np = np.array(image) # PIL to numpy, HWC + + image_np = image_video_dataset.resize_image_to_bucket(image_np, (w, h)) # TODO move this to this file + image_tensor = torch.from_numpy(image_np).float() / 127.5 - 1.0 # -1 to 1.0, HWC + image_tensor = image_tensor.permute(2, 0, 1).unsqueeze(0) # HWC -> CHW -> NCHW, N=1 + return image_tensor, image_np, alpha diff --git a/src/musubi_tuner/utils/lora_utils.py b/src/musubi_tuner/utils/lora_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2c75cbad31914f95683a7468ed09b0e986e6f218 --- /dev/null +++ b/src/musubi_tuner/utils/lora_utils.py @@ -0,0 +1,296 @@ +import os +import re +from typing import Dict, List, Optional, Union +import torch + +import logging + +from tqdm import tqdm + +from musubi_tuner.utils.device_utils import synchronize_device + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +from musubi_tuner.modules.fp8_optimization_utils import load_safetensors_with_fp8_optimization +from musubi_tuner.utils.safetensors_utils import ( + MemoryEfficientSafeOpen, + TensorWeightAdapter, + WeightTransformHooks, + get_split_weight_filenames, +) + + +def detect_network_type(lora_sd: Dict[str, torch.Tensor]) -> str: + """Detect network type (lora, loha, lokr) from state dict keys.""" + for key in lora_sd: + if "lora_down" in key: + return "lora" + if "hada_w1_a" in key: + return "loha" + if "lokr_w1" in key: + return "lokr" + return "lora" # default + + +def filter_lora_state_dict( + weights_sd: Dict[str, torch.Tensor], + include_pattern: Optional[str] = None, + exclude_pattern: Optional[str] = None, +) -> Dict[str, torch.Tensor]: + # apply include/exclude patterns + original_key_count = len(weights_sd.keys()) + if include_pattern is not None: + regex_include = re.compile(include_pattern) + weights_sd = {k: v for k, v in weights_sd.items() if regex_include.search(k)} + logger.info(f"Filtered keys with include pattern {include_pattern}: {original_key_count} -> {len(weights_sd.keys())}") + + if exclude_pattern is not None: + original_key_count_ex = len(weights_sd.keys()) + regex_exclude = re.compile(exclude_pattern) + weights_sd = {k: v for k, v in weights_sd.items() if not regex_exclude.search(k)} + logger.info(f"Filtered keys with exclude pattern {exclude_pattern}: {original_key_count_ex} -> {len(weights_sd.keys())}") + + if len(weights_sd) != original_key_count: + remaining_keys = list(set([k.split(".", 1)[0] for k in weights_sd.keys()])) + remaining_keys.sort() + logger.info(f"Remaining LoRA modules after filtering: {remaining_keys}") + if len(weights_sd) == 0: + logger.warning("No keys left after filtering.") + + return weights_sd + + +def load_safetensors_with_lora_and_fp8( + model_files: Union[str, List[str]], + lora_weights_list: Optional[List[Dict[str, torch.Tensor]]], + lora_multipliers: Optional[List[float]], + fp8_optimization: bool, + calc_device: torch.device, + move_to_device: bool = False, + dit_weight_dtype: Optional[torch.dtype] = None, + target_keys: Optional[List[str]] = None, + exclude_keys: Optional[List[str]] = None, + disable_numpy_memmap: bool = False, + weight_transform_hooks: Optional[WeightTransformHooks] = None, +) -> dict[str, torch.Tensor]: + """ + Merge LoRA weights into the state dict of a model with fp8 optimization if needed. + + Args: + model_files (Union[str, List[str]]): Path to the model file or list of paths. If the path matches a pattern like `00001-of-00004`, it will load all files with the same prefix. + lora_weights_list (Optional[List[Dict[str, torch.Tensor]]]): List of dictionaries of LoRA weight tensors to load. + lora_multipliers (Optional[List[float]]): List of multipliers for LoRA weights. + fp8_optimization (bool): Whether to apply FP8 optimization. + calc_device (torch.device): Device to calculate on. + move_to_device (bool): Whether to move tensors to the calculation device after loading. + target_keys (Optional[List[str]]): Keys to target for optimization. + exclude_keys (Optional[List[str]]): Keys to exclude from optimization. + disable_numpy_memmap (bool): Whether to disable numpy memmap when loading safetensors. + weight_transform_hooks (Optional[WeightTransformHooks]): Hooks for transforming weights during loading. + """ + + # if the file name ends with 00001-of-00004 etc, we need to load the files with the same prefix + if isinstance(model_files, str): + model_files = [model_files] + + extended_model_files = [] + for model_file in model_files: + split_filenames = get_split_weight_filenames(model_file) + if split_filenames is not None: + extended_model_files.extend(split_filenames) + else: + extended_model_files.append(model_file) + model_files = extended_model_files + logger.info(f"Loading model files: {model_files}") + + # load LoRA weights + weight_hook = None + if lora_weights_list is None or len(lora_weights_list) == 0: + lora_weights_list = [] + lora_multipliers = [] + list_of_lora_weight_keys = [] + else: + list_of_lora_weight_keys = [] + for lora_sd in lora_weights_list: + lora_weight_keys = set(lora_sd.keys()) + list_of_lora_weight_keys.append(lora_weight_keys) + + if lora_multipliers is None: + lora_multipliers = [1.0] * len(lora_weights_list) + while len(lora_multipliers) < len(lora_weights_list): + lora_multipliers.append(1.0) + if len(lora_multipliers) > len(lora_weights_list): + lora_multipliers = lora_multipliers[: len(lora_weights_list)] + + # detect network types for each lora_sd + lora_network_types = [detect_network_type(lora_sd) for lora_sd in lora_weights_list] + + # Merge LoRA weights into the state dict + logger.info(f"Merging LoRA weights into state dict. multipliers: {lora_multipliers}, network types: {lora_network_types}") + + # make hook for LoRA merging + def weight_hook_func(model_weight_key, model_weight: torch.Tensor, keep_on_calc_device=False): + nonlocal list_of_lora_weight_keys, lora_weights_list, lora_multipliers, lora_network_types, calc_device + + if not model_weight_key.endswith(".weight"): + return model_weight + + original_device = model_weight.device + if original_device != calc_device: + model_weight = model_weight.to(calc_device) # to make calculation faster + + for lora_weight_keys, lora_sd, multiplier, net_type in zip( + list_of_lora_weight_keys, lora_weights_list, lora_multipliers, lora_network_types + ): + lora_name = model_weight_key.rsplit(".", 1)[0] # remove trailing ".weight" + lora_name = "lora_unet_" + lora_name.replace(".", "_") + + if net_type == "loha": + from musubi_tuner.networks.loha import merge_weights_to_tensor as loha_merge + + model_weight = loha_merge(model_weight, lora_name, lora_sd, lora_weight_keys, multiplier, calc_device) + elif net_type == "lokr": + from musubi_tuner.networks.lokr import merge_weights_to_tensor as lokr_merge + + model_weight = lokr_merge(model_weight, lora_name, lora_sd, lora_weight_keys, multiplier, calc_device) + else: + # standard LoRA (lora_down/lora_up) + down_key = lora_name + ".lora_down.weight" + up_key = lora_name + ".lora_up.weight" + alpha_key = lora_name + ".alpha" + if down_key not in lora_weight_keys or up_key not in lora_weight_keys: + continue + + # get LoRA weights + down_weight = lora_sd[down_key] + up_weight = lora_sd[up_key] + + dim = down_weight.size()[0] + alpha = lora_sd.get(alpha_key, dim) + scale = alpha / dim + + down_weight = down_weight.to(calc_device) + up_weight = up_weight.to(calc_device) + + original_dtype = model_weight.dtype + if original_dtype.itemsize == 1: # fp8 + # temporarily convert to float16 for calculation + model_weight = model_weight.to(torch.float16) + down_weight = down_weight.to(torch.float16) + up_weight = up_weight.to(torch.float16) + + # W <- W + U * D + if len(model_weight.size()) == 2: + # linear + if len(up_weight.size()) == 4: # use linear projection mismatch + up_weight = up_weight.squeeze(3).squeeze(2) + down_weight = down_weight.squeeze(3).squeeze(2) + model_weight = model_weight + multiplier * (up_weight @ down_weight) * scale + elif down_weight.size()[2:4] == (1, 1): + # conv2d 1x1 + model_weight = ( + model_weight + + multiplier + * (up_weight.squeeze(3).squeeze(2) @ down_weight.squeeze(3).squeeze(2)).unsqueeze(2).unsqueeze(3) + * scale + ) + else: + # conv2d 3x3 + conved = torch.nn.functional.conv2d(down_weight.permute(1, 0, 2, 3), up_weight).permute(1, 0, 2, 3) + model_weight = model_weight + multiplier * conved * scale + + if original_dtype.itemsize == 1: # fp8 + model_weight = model_weight.to(original_dtype) # convert back to original dtype + + # remove LoRA keys from set + lora_weight_keys.remove(down_key) + lora_weight_keys.remove(up_key) + if alpha_key in lora_weight_keys: + lora_weight_keys.remove(alpha_key) + + if not keep_on_calc_device and original_device != calc_device: + model_weight = model_weight.to(original_device) # move back to original device + return model_weight + + weight_hook = weight_hook_func + + state_dict = load_safetensors_with_fp8_optimization_and_hook( + model_files, + fp8_optimization, + calc_device, + move_to_device, + dit_weight_dtype, + target_keys, + exclude_keys, + weight_hook=weight_hook, + disable_numpy_memmap=disable_numpy_memmap, + weight_transform_hooks=weight_transform_hooks, + ) + + for lora_weight_keys in list_of_lora_weight_keys: + # check if all LoRA keys are used + if len(lora_weight_keys) > 0: + # if there are still LoRA keys left, it means they are not used in the model + # this is a warning, not an error + logger.warning(f"Warning: not all LoRA keys are used: {', '.join(lora_weight_keys)}") + + return state_dict + + +def load_safetensors_with_fp8_optimization_and_hook( + model_files: list[str], + fp8_optimization: bool, + calc_device: torch.device, + move_to_device: bool = False, + dit_weight_dtype: Optional[torch.dtype] = None, + target_keys: Optional[List[str]] = None, + exclude_keys: Optional[List[str]] = None, + weight_hook: callable = None, + disable_numpy_memmap: bool = False, + weight_transform_hooks: Optional[WeightTransformHooks] = None, +) -> dict[str, torch.Tensor]: + """ + Load state dict from safetensors files and merge LoRA weights into the state dict with fp8 optimization if needed. + """ + if fp8_optimization: + logger.info( + f"Loading state dict with FP8 optimization. Dtype of weight: {dit_weight_dtype}, hook enabled: {weight_hook is not None}" + ) + # dit_weight_dtype is not used because we use fp8 optimization + state_dict = load_safetensors_with_fp8_optimization( + model_files, + calc_device, + target_keys, + exclude_keys, + move_to_device=move_to_device, + weight_hook=weight_hook, + disable_numpy_memmap=disable_numpy_memmap, + weight_transform_hooks=weight_transform_hooks, + ) + else: + logger.info( + f"Loading state dict without FP8 optimization. Dtype of weight: {dit_weight_dtype}, hook enabled: {weight_hook is not None}" + ) + state_dict = {} + for model_file in model_files: + with MemoryEfficientSafeOpen(model_file, disable_numpy_memmap=disable_numpy_memmap) as original_f: + f = TensorWeightAdapter(weight_transform_hooks, original_f) if weight_transform_hooks is not None else original_f + for key in tqdm(f.keys(), desc=f"Loading {os.path.basename(model_file)}", leave=False): + if weight_hook is None and move_to_device: + value = f.get_tensor(key, device=calc_device, dtype=dit_weight_dtype) + else: + value = f.get_tensor(key) # we cannot directly load to device because get_tensor does non-blocking transfer + if weight_hook is not None: + value = weight_hook(key, value, keep_on_calc_device=move_to_device) + if move_to_device: + value = value.to(calc_device, dtype=dit_weight_dtype, non_blocking=True) + elif dit_weight_dtype is not None: + value = value.to(dit_weight_dtype) + + state_dict[key] = value + if move_to_device: + synchronize_device(calc_device) + + return state_dict diff --git a/src/musubi_tuner/utils/safetensors_utils.py b/src/musubi_tuner/utils/safetensors_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f50e64313edb0cd9c2bddff5374612544d0df559 --- /dev/null +++ b/src/musubi_tuner/utils/safetensors_utils.py @@ -0,0 +1,463 @@ +from dataclasses import dataclass +import os +import re +import numpy as np +import torch +import json +import struct +from typing import Dict, Any, Union, Optional + +from safetensors.torch import load_file + +from musubi_tuner.utils.device_utils import synchronize_device + + +def mem_eff_save_file(tensors: Dict[str, torch.Tensor], filename: str, metadata: Dict[str, Any] = None): + """ + memory efficient save file + """ + + _TYPES = { + torch.float64: "F64", + torch.float32: "F32", + torch.float16: "F16", + torch.bfloat16: "BF16", + torch.int64: "I64", + torch.int32: "I32", + torch.int16: "I16", + torch.int8: "I8", + torch.uint8: "U8", + torch.bool: "BOOL", + getattr(torch, "float8_e5m2", None): "F8_E5M2", + getattr(torch, "float8_e4m3fn", None): "F8_E4M3", + } + _ALIGN = 256 + + def validate_metadata(metadata: Dict[str, Any]) -> Dict[str, str]: + validated = {} + for key, value in metadata.items(): + if not isinstance(key, str): + raise ValueError(f"Metadata key must be a string, got {type(key)}") + if not isinstance(value, str): + print(f"Warning: Metadata value for key '{key}' is not a string. Converting to string.") + validated[key] = str(value) + else: + validated[key] = value + return validated + + # print(f"Using memory efficient save file: {filename}") + + header = {} + offset = 0 + if metadata: + header["__metadata__"] = validate_metadata(metadata) + for k, v in tensors.items(): + if v.numel() == 0: # empty tensor + header[k] = {"dtype": _TYPES[v.dtype], "shape": list(v.shape), "data_offsets": [offset, offset]} + else: + size = v.numel() * v.element_size() + header[k] = {"dtype": _TYPES[v.dtype], "shape": list(v.shape), "data_offsets": [offset, offset + size]} + offset += size + + hjson = json.dumps(header).encode("utf-8") + hjson += b" " * (-(len(hjson) + 8) % _ALIGN) + + with open(filename, "wb") as f: + f.write(struct.pack(" Dict[str, str]: + """Get metadata from the file. + + Returns: + Dict[str, str]: Metadata dictionary. + """ + return self.header.get("__metadata__", {}) + + def _read_header(self): + """Read and parse the header from the safetensors file. + + Returns: + tuple: (header_dict, header_size) containing parsed header and its size. + """ + # Read header size (8 bytes, little-endian unsigned long long) + header_size = struct.unpack("10MB) and the target device is CUDA, memory mapping with numpy.memmap is used to avoid intermediate copies. + + Args: + key (str): Name of the tensor to load. + device (Optional[torch.device]): Target device for the tensor. + dtype (Optional[torch.dtype]): Target dtype for the tensor. + + Returns: + torch.Tensor: The loaded tensor. + + Raises: + KeyError: If the tensor key is not found in the file. + """ + if key not in self.header: + raise KeyError(f"Tensor '{key}' not found in the file") + + metadata = self.header[key] + offset_start, offset_end = metadata["data_offsets"] + num_bytes = offset_end - offset_start + + original_dtype = self._get_torch_dtype(metadata["dtype"]) + target_dtype = dtype if dtype is not None else original_dtype + + # Handle empty tensors + if num_bytes == 0: + return torch.empty(metadata["shape"], dtype=target_dtype, device=device) + + # Determine if we should use pinned memory for GPU transfer + non_blocking = device is not None and device.type == "cuda" + + # Calculate absolute file offset + tensor_offset = self.header_size + 8 + offset_start # adjust offset by header size + + # Memory mapping strategy for large tensors to GPU + # Use memmap for large tensors to avoid intermediate copies. + # If device is cpu, tensor is not copied to gpu, so using memmap locks the file, which is not desired. + # So we only use memmap if device is not cpu. + # If disable_numpy_memmap is True, skip numpy memory mapping to load with standard file read. + if not self.disable_numpy_memmap and num_bytes > 10 * 1024 * 1024 and device is not None and device.type != "cpu": + # Create memory map for zero-copy reading + mm = np.memmap(self.filename, mode="c", dtype=np.uint8, offset=tensor_offset, shape=(num_bytes,)) + byte_tensor = torch.from_numpy(mm) # zero copy + del mm + + # Deserialize tensor (view and reshape) + cpu_tensor = self._deserialize_tensor(byte_tensor, metadata) # view and reshape + del byte_tensor + + # Transfer to target device and dtype + gpu_tensor = cpu_tensor.to(device=device, dtype=target_dtype, non_blocking=non_blocking) + del cpu_tensor + return gpu_tensor + + # Standard file reading strategy for smaller tensors or CPU target + # seek to the specified position + self.file.seek(tensor_offset) + + # read directly into a numpy array by numpy.fromfile without intermediate copy + numpy_array = np.fromfile(self.file, dtype=np.uint8, count=num_bytes) + byte_tensor = torch.from_numpy(numpy_array) + del numpy_array + + # deserialize (view and reshape) + deserialized_tensor = self._deserialize_tensor(byte_tensor, metadata) + del byte_tensor + + # cast to target dtype and move to device + return deserialized_tensor.to(device=device, dtype=target_dtype, non_blocking=non_blocking) + + def _deserialize_tensor(self, byte_tensor: torch.Tensor, metadata: Dict): + """Deserialize byte tensor to the correct shape and dtype. + + Args: + byte_tensor (torch.Tensor): Raw byte tensor from file. + metadata (Dict): Tensor metadata containing dtype and shape info. + + Returns: + torch.Tensor: Deserialized tensor with correct shape and dtype. + """ + dtype = self._get_torch_dtype(metadata["dtype"]) + shape = metadata["shape"] + + # Handle special float8 types + if metadata["dtype"] in ["F8_E5M2", "F8_E4M3"]: + return self._convert_float8(byte_tensor, metadata["dtype"], shape) + + # Standard conversion: view as target dtype and reshape + return byte_tensor.view(dtype).reshape(shape) + + @staticmethod + def _get_torch_dtype(dtype_str): + """Convert string dtype to PyTorch dtype. + + Args: + dtype_str (str): String representation of the dtype. + + Returns: + torch.dtype: Corresponding PyTorch dtype. + """ + # Standard dtype mappings + dtype_map = { + "F64": torch.float64, + "F32": torch.float32, + "F16": torch.float16, + "BF16": torch.bfloat16, + "I64": torch.int64, + "I32": torch.int32, + "I16": torch.int16, + "I8": torch.int8, + "U8": torch.uint8, + "BOOL": torch.bool, + } + # Add float8 types if available in PyTorch version + if hasattr(torch, "float8_e5m2"): + dtype_map["F8_E5M2"] = torch.float8_e5m2 + if hasattr(torch, "float8_e4m3fn"): + dtype_map["F8_E4M3"] = torch.float8_e4m3fn + return dtype_map.get(dtype_str) + + @staticmethod + def _convert_float8(byte_tensor, dtype_str, shape): + """Convert byte tensor to float8 format if supported. + + Args: + byte_tensor (torch.Tensor): Raw byte tensor. + dtype_str (str): Float8 dtype string ("F8_E5M2" or "F8_E4M3"). + shape (tuple): Target tensor shape. + + Returns: + torch.Tensor: Tensor with float8 dtype. + + Raises: + ValueError: If float8 type is not supported in current PyTorch version. + """ + # Convert to specific float8 types if available + if dtype_str == "F8_E5M2" and hasattr(torch, "float8_e5m2"): + return byte_tensor.view(torch.float8_e5m2).reshape(shape) + elif dtype_str == "F8_E4M3" and hasattr(torch, "float8_e4m3fn"): + return byte_tensor.view(torch.float8_e4m3fn).reshape(shape) + else: + # Float8 not supported in this PyTorch version + raise ValueError(f"Unsupported float8 type: {dtype_str} (upgrade PyTorch to support float8 types)") + + +def load_safetensors( + path: str, + device: Union[str, torch.device], + disable_mmap: bool = False, + dtype: Optional[torch.dtype] = None, + disable_numpy_memmap: bool = False, +) -> dict[str, torch.Tensor]: + if disable_mmap: + # return safetensors.torch.load(open(path, "rb").read()) + # use experimental loader + # logger.info(f"Loading without mmap (experimental)") + state_dict = {} + device = torch.device(device) if device is not None else None + with MemoryEfficientSafeOpen(path, disable_numpy_memmap=disable_numpy_memmap) as f: + for key in f.keys(): + state_dict[key] = f.get_tensor(key, device=device, dtype=dtype) + synchronize_device(device) + return state_dict + else: + try: + state_dict = load_file(path, device=device) + except: + state_dict = load_file(path) # prevent device invalid Error + if dtype is not None: + for key in state_dict.keys(): + state_dict[key] = state_dict[key].to(dtype=dtype) + return state_dict + + +def get_split_weight_filenames(file_path: str) -> Optional[list[str]]: + """ + Get the list of split weight filenames (full paths) if the file name ends with 00001-of-00004 etc. + Returns None if the file is not split. + """ + basename = os.path.basename(file_path) + match = re.match(r"^(.*?)(\d+)-of-(\d+)\.safetensors$", basename) + if match: + prefix = basename[: match.start(2)] + count = int(match.group(3)) + filenames = [] + for i in range(count): + filename = f"{prefix}{i + 1:05d}-of-{count:05d}.safetensors" + filepath = os.path.join(os.path.dirname(file_path), filename) + if os.path.exists(filepath): + filenames.append(filepath) + else: + raise FileNotFoundError(f"File {filepath} not found") + return filenames + else: + return None + + +def load_split_weights( + file_path: str, device: Union[str, torch.device] = "cpu", disable_mmap: bool = False, dtype: Optional[torch.dtype] = None +) -> Dict[str, torch.Tensor]: + """ + Load split weights from a file. If the file name ends with 00001-of-00004 etc, it will load all files with the same prefix. + dtype is as is, no conversion is done. + """ + device = torch.device(device) + + # if the file name ends with 00001-of-00004 etc, we need to load the files with the same prefix + split_filenames = get_split_weight_filenames(file_path) + if split_filenames is not None: + state_dict = {} + for filename in split_filenames: + state_dict.update(load_safetensors(filename, device=device, disable_mmap=disable_mmap, dtype=dtype)) + else: + state_dict = load_safetensors(file_path, device=device, disable_mmap=disable_mmap, dtype=dtype) + return state_dict + + +def find_key(safetensors_file: str, starts_with: Optional[str] = None, ends_with: Optional[str] = None) -> Optional[str]: + """ + Find a key in a safetensors file that starts with `starts_with` and ends with `ends_with`. + If `starts_with` is None, it will match any key. + If `ends_with` is None, it will match any key. + Returns the first matching key or None if no key matches. + """ + with MemoryEfficientSafeOpen(safetensors_file) as f: + for key in f.keys(): + if (starts_with is None or key.startswith(starts_with)) and (ends_with is None or key.endswith(ends_with)): + return key + return None + + +@dataclass +class WeightTransformHooks: + split_hook: Optional[callable] = None + concat_hook: Optional[callable] = None + + +class TensorWeightAdapter: + """ + A wrapper for weight conversion hooks (split and concat) to be used with MemoryEfficientSafeOpen. + This wrapper adapts the original MemoryEfficientSafeOpen to apply the provided split and concat hooks + when loading tensors. + + split_hook: A callable that takes (original_key: str, original_tensor: torch.Tensor) and returns (new_keys: list[str], new_tensors: list[torch.Tensor]). + concat_hook: A callable that takes (original_key: str, tensors: dict[str, torch.Tensor]) and returns (new_key: str, concatenated_tensor: torch.Tensor). + + If tensors is None, the hook should return only the new keys (for split) or new key (for concat), without tensors. + + No need to implement __enter__ and __exit__ methods, as they are handled by the original MemoryEfficientSafeOpen. + Do not use this wrapper as a context manager directly, like `with WeightConvertHookWrapper(...) as f:`. + + **concat_hook is not tested yet.** + """ + + def __init__(self, weight_convert_hook: WeightTransformHooks, original_f: MemoryEfficientSafeOpen): + self.original_f = original_f + self.new_key_to_original_key_map: dict[ + str, Union[str, list[str]] + ] = {} # for split: new_key -> original_key; for concat: new_key -> list of original_keys + self.concat_key_set = set() # set of keys that are created by concat_hook, to distinguish from split_hook + self.new_keys = [] + self.tensor_cache = {} # cache for split tensors + self.split_hook = weight_convert_hook.split_hook + self.concat_hook = weight_convert_hook.concat_hook + + for key in self.original_f.keys(): + if self.split_hook is not None: + converted_keys, _ = self.split_hook(key, None) # get new keys only + if converted_keys is not None: + for new_key in converted_keys: + self.new_key_to_original_key_map[new_key] = key + self.new_keys.extend(converted_keys) + continue # skip concat_hook if split_hook is applied + + if self.concat_hook is not None: + converted_key, _ = self.concat_hook(key, None) # get new key only + if converted_key is not None: + if converted_key not in self.concat_key_set: # first time seeing this concatenated key + self.concat_key_set.add(converted_key) + self.new_key_to_original_key_map[converted_key] = [] + + # multiple original keys map to the same concatenated key + self.new_key_to_original_key_map[converted_key].append(key) + + self.new_keys.append(converted_key) + continue # skip to next key + + # direct mapping + self.new_keys.append(key) + + def keys(self) -> list[str]: + return self.new_keys + + def get_tensor(self, new_key: str, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None) -> torch.Tensor: + # load tensor by new_key, applying split or concat hooks as needed + if new_key not in self.new_key_to_original_key_map: + # direct mapping + return self.original_f.get_tensor(new_key, device=device, dtype=dtype) + + elif new_key not in self.concat_key_set: + # split hook: split key is requested multiple times, so we cache the result + original_key = self.new_key_to_original_key_map[new_key] + if original_key not in self.tensor_cache: # not yet split + original_tensor = self.original_f.get_tensor(original_key, device=device, dtype=dtype) + new_keys, new_tensors = self.split_hook(original_key, original_tensor) # apply split hook + for k, t in zip(new_keys, new_tensors): + self.tensor_cache[k] = t + return self.tensor_cache.pop(new_key) # return and remove from cache + + else: + # concat hook: concatenated key is requested only once, so we do not cache the result + tensors = {} + for original_key in self.new_key_to_original_key_map[new_key]: + tensor = self.original_f.get_tensor(original_key, device=device, dtype=dtype) + tensors[original_key] = tensor + _, concatenated_tensors = self.concat_hook(self.new_key_to_original_key_map[new_key][0], tensors) # apply concat hook + return concatenated_tensors diff --git a/src/musubi_tuner/zimage/zimage_config.py b/src/musubi_tuner/zimage/zimage_config.py new file mode 100644 index 0000000000000000000000000000000000000000..5da2bdd7ce4f17bc04f67f3377377efa6aef5b35 --- /dev/null +++ b/src/musubi_tuner/zimage/zimage_config.py @@ -0,0 +1,83 @@ +# Copyright (c) 2025 Z-Image Team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# This file has been modified from the original version. +# Original implementation: https://github.com/Tongyi-MAI/Z-Image +# Modifications: Copied and modified for Musubi Tuner project. + +# region Inference Configuration Constants + +"""Inference-specific configuration for Z-Image.""" + +DEFAULT_HEIGHT = 1024 +DEFAULT_WIDTH = 1024 +DEFAULT_INFERENCE_STEPS = 8 +DEFAULT_GUIDANCE_SCALE = 0.0 +DEFAULT_CFG_TRUNCATION = 1.0 +DEFAULT_MAX_SEQUENCE_LENGTH = 512 + +# endregion + +# region Z-Image Model Configuration Constants + +"""Model configuration constants for Z-Image.""" + +ADALN_EMBED_DIM = 256 +SEQ_MULTI_OF = 32 + +ROPE_THETA = 256.0 +ROPE_AXES_DIMS = [32, 48, 48] +ROPE_AXES_LENS = [1536, 512, 512] + +FREQUENCY_EMBEDDING_SIZE = 256 +MAX_PERIOD = 10000 + +BASE_IMAGE_SEQ_LEN = 256 +MAX_IMAGE_SEQ_LEN = 4096 +BASE_SHIFT = 0.5 +MAX_SHIFT = 1.15 + +DEFAULT_VAE_SCALE_FACTOR = 8 +DEFAULT_VAE_IN_CHANNELS = 3 +DEFAULT_VAE_OUT_CHANNELS = 3 +# DEFAULT_VAE_LATENT_CHANNELS = 4 +ZIMAGE_VAE_LATENT_CHANNELS = 16 +DEFAULT_VAE_NORM_NUM_GROUPS = 32 +# DEFAULT_VAE_SCALING_FACTOR = 0.18215 +ZIMAGE_VAE_SCALING_FACTOR = 0.3611 +ZIMAGE_VAE_SHIFT_FACTOR = 0.1159 +ZIMAGE_VAE_SCALE_FACTOR = 8 # 2 ** (len(block_out_channels) - 1) +DEFAULT_TRANSFORMER_PATCH_SIZE = (2,) +DEFAULT_TRANSFORMER_F_PATCH_SIZE = (1,) +DEFAULT_TRANSFORMER_IN_CHANNELS = 16 +DEFAULT_TRANSFORMER_DIM = 3840 +DEFAULT_TRANSFORMER_N_LAYERS = 30 +DEFAULT_TRANSFORMER_N_REFINER_LAYERS = 2 +DEFAULT_TRANSFORMER_N_HEADS = 30 +DEFAULT_TRANSFORMER_N_KV_HEADS = 30 +DEFAULT_TRANSFORMER_NORM_EPS = 1e-5 +DEFAULT_TRANSFORMER_QK_NORM = True +DEFAULT_TRANSFORMER_CAP_FEAT_DIM = 2560 +DEFAULT_TRANSFORMER_T_SCALE = 1000.0 + +DEFAULT_SCHEDULER_NUM_TRAIN_TIMESTEPS = 1000 +DEFAULT_SCHEDULER_SHIFT = 3.0 +DEFAULT_SCHEDULER_USE_DYNAMIC_SHIFTING = False + +DEFAULT_LOAD_DEVICE = "cuda" +DEFAULT_LOAD_DTYPE_STR = "bfloat16" + +BYTES_PER_GB = 2**30 + +# endregion diff --git a/src/musubi_tuner/zimage/zimage_model.py b/src/musubi_tuner/zimage/zimage_model.py new file mode 100644 index 0000000000000000000000000000000000000000..79f0dc393d729471d19d945f57f0898b8c4aa0dc --- /dev/null +++ b/src/musubi_tuner/zimage/zimage_model.py @@ -0,0 +1,855 @@ +# Copyright (c) 2025 Z-Image Team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# This file has been modified from the original version. +# Original implementation: https://github.com/Tongyi-MAI/Z-Image +# Modifications: Copied and modified for Musubi Tuner project. + +"""Z-Image Transformer.""" + +import math +from typing import Dict, List, Optional, Tuple, Union +import logging + +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch.utils.checkpoint import checkpoint +from accelerate import init_empty_weights + +from musubi_tuner.modules.attention import AttentionParams, attention +from musubi_tuner.modules.custom_offloading_utils import ModelOffloader +from musubi_tuner.modules.fp8_optimization_utils import apply_fp8_monkey_patch +from musubi_tuner.utils.lora_utils import load_safetensors_with_lora_and_fp8 +from musubi_tuner.utils.safetensors_utils import WeightTransformHooks + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + +from musubi_tuner.utils.model_utils import create_cpu_offloading_wrapper +from musubi_tuner.zimage import zimage_config +from musubi_tuner.zimage.zimage_config import ( + ADALN_EMBED_DIM, + FREQUENCY_EMBEDDING_SIZE, + MAX_PERIOD, + ROPE_AXES_DIMS, + ROPE_AXES_LENS, + ROPE_THETA, +) + + +class TimestepEmbedder(nn.Module): + def __init__(self, out_size, mid_size=None, frequency_embedding_size=FREQUENCY_EMBEDDING_SIZE): + super().__init__() + if mid_size is None: + mid_size = out_size + self.mlp = nn.Sequential( + nn.Linear(frequency_embedding_size, mid_size, bias=True), + nn.SiLU(), + nn.Linear(mid_size, out_size, bias=True), + ) + self.frequency_embedding_size = frequency_embedding_size + + @staticmethod + def timestep_embedding(t, dim, max_period=MAX_PERIOD): + with torch.amp.autocast("cuda", enabled=False): + half = dim // 2 + freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32, device=t.device) / half) + args = t[:, None].float() * freqs[None] + embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1) + if dim % 2: + embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1) + return embedding + + def forward(self, t): + t_freq = self.timestep_embedding(t, self.frequency_embedding_size) + weight_dtype = self.mlp[0].weight.dtype + if weight_dtype.is_floating_point: + t_freq = t_freq.to(weight_dtype) + t_emb = self.mlp(t_freq) + return t_emb + + +class RMSNorm(nn.Module): + def __init__(self, dim: int, eps: float = 1e-5): + super().__init__() + self.eps = eps + self.weight = nn.Parameter(torch.ones(dim)) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + # original implementation. kept for reference + # output = x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) + # return output * self.weight + + # cast to float32 for numerical stability + x_f = x.float() + w_f = self.weight.float() + out = x_f * torch.rsqrt(x_f.pow(2).mean(-1, keepdim=True) + self.eps) + return (out * w_f).to(x.dtype) + + +def clamp_fp16(x): + if x.dtype == torch.float16: + return torch.nan_to_num(x, nan=0.0, posinf=65504, neginf=-65504) + return x + + +class FeedForward(nn.Module): + def __init__(self, dim: int, hidden_dim: int): + super().__init__() + self.w1 = nn.Linear(dim, hidden_dim, bias=False) + self.w2 = nn.Linear(hidden_dim, dim, bias=False) + self.w3 = nn.Linear(dim, hidden_dim, bias=False) + + self.gradient_checkpointing = False + + def enable_gradient_checkpointing(self): + self.gradient_checkpointing = True + + def disable_gradient_checkpointing(self): + self.gradient_checkpointing = False + + def _forward(self, x, apply_fp16_downscale=False): + x3 = self.w3(x) + if x.dtype == torch.float16 and apply_fp16_downscale: + x3.div_(32) + return self.w2(clamp_fp16(F.silu(self.w1(x)) * x3)) + + def forward(self, x, apply_fp16_downscale=False): + if self.training and self.gradient_checkpointing: + return checkpoint(self._forward, x, use_reentrant=False) + else: + return self._forward(x, apply_fp16_downscale) + + +def apply_rotary_emb(x_in: torch.Tensor, freqs_cis: torch.Tensor) -> torch.Tensor: + with torch.amp.autocast("cuda", enabled=False): + x = torch.view_as_complex(x_in.float().reshape(*x_in.shape[:-1], -1, 2)) + freqs_cis = freqs_cis.unsqueeze(2) + x_out = torch.view_as_real(x * freqs_cis).flatten(3) + return x_out.type_as(x_in) + + +class ZImageAttention(nn.Module): + _attention_backend = None + + def __init__(self, dim: int, n_heads: int, n_kv_heads: int, qk_norm: bool = True, eps: float = 1e-5, use_16bit: bool = False): + super().__init__() + self.n_heads = n_heads + self.n_kv_heads = n_kv_heads + self.head_dim = dim // n_heads + self.use_16bit = use_16bit + + self.to_q = nn.Linear(dim, n_heads * self.head_dim, bias=False) + self.to_k = nn.Linear(dim, n_kv_heads * self.head_dim, bias=False) + self.to_v = nn.Linear(dim, n_kv_heads * self.head_dim, bias=False) + self.to_out = nn.ModuleList([nn.Linear(n_heads * self.head_dim, dim, bias=False)]) + + self.norm_q = RMSNorm(self.head_dim, eps=eps) if qk_norm else None + self.norm_k = RMSNorm(self.head_dim, eps=eps) if qk_norm else None + + self.gradient_checkpointing = False + + def enable_gradient_checkpointing(self): + self.gradient_checkpointing = True + + def disable_gradient_checkpointing(self): + self.gradient_checkpointing = False + + def _forward( + self, hidden_states: torch.Tensor, freqs_cis: Optional[torch.Tensor] = None, attn_params: Optional[AttentionParams] = None + ) -> torch.Tensor: + query = self.to_q(hidden_states) + key = self.to_k(hidden_states) + value = self.to_v(hidden_states) + + query = query.unflatten(-1, (self.n_heads, -1)) # [B, seq_len, n_heads, head_dim] + key = key.unflatten(-1, (self.n_kv_heads, -1)) + value = value.unflatten(-1, (self.n_kv_heads, -1)) + + if self.norm_q is not None: + query = self.norm_q(query) + if self.norm_k is not None: + key = self.norm_k(key) + + if freqs_cis is not None: + query = apply_rotary_emb(query, freqs_cis) + key = apply_rotary_emb(key, freqs_cis) + + # query.dtype is float32. It is imcompatible with FlashAttention, so we convert to the original dtype if use_16bit is set. + dtype = query.dtype if not self.use_16bit else value.dtype + query, key = query.to(dtype), key.to(dtype) + + # Call attention + qkv = [query, key, value] + del query, key, value + hidden_states = attention(qkv, attn_params=attn_params) + del qkv + + hidden_states = hidden_states.to(dtype) + + output = self.to_out[0](hidden_states) + if output.dtype == torch.float16: + output.div_(4) + return output + + def forward( + self, hidden_states: torch.Tensor, freqs_cis: Optional[torch.Tensor] = None, attn_params: Optional[AttentionParams] = None + ) -> torch.Tensor: + if self.training and self.gradient_checkpointing: + return checkpoint(self._forward, hidden_states, freqs_cis, attn_params, use_reentrant=False) + else: + return self._forward(hidden_states, freqs_cis, attn_params) + + +class ZImageTransformerBlock(nn.Module): + def __init__( + self, + layer_id: int, + dim: int, + n_heads: int, + n_kv_heads: int, + norm_eps: float, + qk_norm: bool, + modulation=True, + use_16bit: bool = False, + ): + super().__init__() + self.dim = dim + self.head_dim = dim // n_heads + self.layer_id = layer_id + self.modulation = modulation + + self.attention = ZImageAttention(dim, n_heads, n_kv_heads, qk_norm, norm_eps, use_16bit=use_16bit) + self.feed_forward = FeedForward(dim=dim, hidden_dim=int(dim / 3 * 8)) + + self.attention_norm1 = RMSNorm(dim, eps=norm_eps) + self.ffn_norm1 = RMSNorm(dim, eps=norm_eps) + self.attention_norm2 = RMSNorm(dim, eps=norm_eps) + self.ffn_norm2 = RMSNorm(dim, eps=norm_eps) + + if modulation: + self.adaLN_modulation = nn.ModuleList([nn.Linear(min(dim, ADALN_EMBED_DIM), 4 * dim, bias=True)]) + + self.gradient_checkpointing = False + self.activation_cpu_offloading = False + + def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False): + self.gradient_checkpointing = True + self.activation_cpu_offloading = activation_cpu_offloading + self.feed_forward.enable_gradient_checkpointing() + self.attention.enable_gradient_checkpointing() + + def disable_gradient_checkpointing(self): + self.gradient_checkpointing = False + self.activation_cpu_offloading = False + self.feed_forward.disable_gradient_checkpointing() + self.attention.disable_gradient_checkpointing() + + def _forward( + self, + x: torch.Tensor, + freqs_cis: torch.Tensor, + adaln_input: Optional[torch.Tensor] = None, + attn_params: Optional[AttentionParams] = None, + ): + if self.modulation: + assert adaln_input is not None + scale_msa, gate_msa, scale_mlp, gate_mlp = self.adaLN_modulation[0](adaln_input).unsqueeze(1).chunk(4, dim=2) + del adaln_input + gate_msa, gate_mlp = gate_msa.tanh(), gate_mlp.tanh() + scale_msa, scale_mlp = 1.0 + scale_msa, 1.0 + scale_mlp + + attn_out = self.attention(self.attention_norm1(x) * scale_msa, freqs_cis=freqs_cis, attn_params=attn_params) + del scale_msa + x = x + gate_msa * self.attention_norm2(clamp_fp16(attn_out)) + del gate_msa + x = x + gate_mlp * self.ffn_norm2( + clamp_fp16(self.feed_forward(self.ffn_norm1(x) * scale_mlp, apply_fp16_downscale=True)) + ) + del scale_mlp, gate_mlp + else: + attn_out = self.attention(self.attention_norm1(x), freqs_cis=freqs_cis, attn_params=attn_params) + x = x + self.attention_norm2(clamp_fp16(attn_out)) + x = x + self.ffn_norm2(self.feed_forward(self.ffn_norm1(x))) + + return x + + def forward( + self, + x: torch.Tensor, + freqs_cis: torch.Tensor, + adaln_input: Optional[torch.Tensor] = None, + attn_params: Optional[AttentionParams] = None, + ): + if self.training and self.gradient_checkpointing: + forward_fn = self._forward + if self.activation_cpu_offloading: + forward_fn = create_cpu_offloading_wrapper(forward_fn, self.feed_forward.w1.weight.device) + return checkpoint(forward_fn, x, freqs_cis, adaln_input, attn_params, use_reentrant=False) + else: + return self._forward(x, freqs_cis, adaln_input, attn_params) + + +class FinalLayer(nn.Module): + def __init__(self, hidden_size, out_channels): + super().__init__() + self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) + self.linear = nn.Linear(hidden_size, out_channels, bias=True) + self.adaLN_modulation = nn.Sequential( + nn.SiLU(), + nn.Linear(min(hidden_size, ADALN_EMBED_DIM), hidden_size, bias=True), + ) + + def forward(self, x, c): + scale = 1.0 + self.adaLN_modulation(c) + x = self.norm_final(x) * scale.unsqueeze(1) + x = self.linear(x) + return x + + +class RopeEmbedder: + def __init__(self, theta: float = ROPE_THETA, axes_dims: List[int] = ROPE_AXES_DIMS, axes_lens: List[int] = ROPE_AXES_LENS): + self.theta = theta + self.axes_dims = axes_dims + self.axes_lens = axes_lens + assert len(axes_dims) == len(axes_lens) + self.freqs_cis = None + + @staticmethod + def precompute_freqs_cis(dim: List[int], end: List[int], theta: float = ROPE_THETA): + with torch.device("cpu"): + freqs_cis = [] + for i, (d, e) in enumerate(zip(dim, end)): + freqs = 1.0 / (theta ** (torch.arange(0, d, 2, dtype=torch.float64, device="cpu") / d)) + timestep = torch.arange(e, device=freqs.device, dtype=torch.float64) + freqs = torch.outer(timestep, freqs).float() + freqs_cis_i = torch.polar(torch.ones_like(freqs), freqs).to(torch.complex64) + freqs_cis.append(freqs_cis_i) + return freqs_cis + + def __call__(self, ids: torch.Tensor): + assert ids.ndim == 2 + assert ids.shape[-1] == len(self.axes_dims) + device = ids.device + + if self.freqs_cis is None: + # [torch.Size([1536, 16]), torch.Size([512, 24]), torch.Size([512, 24])] + self.freqs_cis = self.precompute_freqs_cis(self.axes_dims, self.axes_lens, theta=self.theta) # keep on cpu + + result = [] + for i in range(len(self.axes_dims)): + index = ids[:, i] + result.append(self.freqs_cis[i].to(device)[index]) + return torch.cat(result, dim=-1) + + +class ZImageTransformer2DModel(nn.Module): + def __init__( + self, + all_patch_size=(2,), + all_f_patch_size=(1,), + in_channels=16, + dim=3840, + n_layers=30, + n_refiner_layers=2, + n_heads=30, + n_kv_heads=30, + norm_eps=1e-5, + qk_norm=True, + cap_feat_dim=2560, + rope_theta=ROPE_THETA, + t_scale=1000.0, + axes_dims=ROPE_AXES_DIMS, + axes_lens=ROPE_AXES_LENS, + attn_mode: str = "torch", + split_attn: bool = False, + use_16bit_for_attention: bool = False, + ): + super().__init__() + self.in_channels = in_channels + self.out_channels = in_channels + self.all_patch_size = all_patch_size + self.all_f_patch_size = all_f_patch_size + self.dim = dim + self.n_heads = n_heads + self.rope_theta = rope_theta + self.t_scale = t_scale + self.attn_mode = attn_mode + self.split_attn = split_attn + + assert len(all_patch_size) == len(all_f_patch_size) + + all_x_embedder = {} + all_final_layer = {} + for patch_size, f_patch_size in zip(all_patch_size, all_f_patch_size): + x_embedder = nn.Linear(f_patch_size * patch_size * patch_size * in_channels, dim, bias=True) + all_x_embedder[f"{patch_size}-{f_patch_size}"] = x_embedder + final_layer = FinalLayer(dim, patch_size * patch_size * f_patch_size * self.out_channels) + all_final_layer[f"{patch_size}-{f_patch_size}"] = final_layer + + self.all_x_embedder = nn.ModuleDict(all_x_embedder) + self.all_final_layer = nn.ModuleDict(all_final_layer) + + self.noise_refiner = nn.ModuleList( + [ + ZImageTransformerBlock( + 1000 + layer_id, dim, n_heads, n_kv_heads, norm_eps, qk_norm, modulation=True, use_16bit=use_16bit_for_attention + ) + for layer_id in range(n_refiner_layers) + ] + ) + + self.context_refiner = nn.ModuleList( + [ + ZImageTransformerBlock( + layer_id, dim, n_heads, n_kv_heads, norm_eps, qk_norm, modulation=False, use_16bit=use_16bit_for_attention + ) + for layer_id in range(n_refiner_layers) + ] + ) + + self.t_embedder = TimestepEmbedder(min(dim, ADALN_EMBED_DIM), mid_size=1024) + self.cap_embedder = nn.Sequential( + RMSNorm(cap_feat_dim, eps=norm_eps), + nn.Linear(cap_feat_dim, dim, bias=True), + ) + + self.x_pad_token = nn.Parameter(torch.empty((1, dim))) + self.cap_pad_token = nn.Parameter(torch.empty((1, dim))) + + self.layers = nn.ModuleList( + [ + ZImageTransformerBlock(layer_id, dim, n_heads, n_kv_heads, norm_eps, qk_norm, use_16bit=use_16bit_for_attention) + for layer_id in range(n_layers) + ] + ) + + head_dim = dim // n_heads + assert head_dim == sum(axes_dims) + self.axes_dims = axes_dims + self.axes_lens = axes_lens + + self.rope_embedder = RopeEmbedder(theta=rope_theta, axes_dims=axes_dims, axes_lens=axes_lens) + + self.gradient_checkpointing = False + self.activation_cpu_offloading = False + self.blocks_to_swap = None + + self.offloader = None + self.num_blocks = n_layers + + @property + def device(self): + return next(self.parameters()).device + + @property + def dtype(self): + return next(self.parameters()).dtype + + def enable_gradient_checkpointing(self, cpu_offload: bool = False): + self.gradient_checkpointing = True + self.activation_cpu_offloading = cpu_offload + + for block in self.noise_refiner + self.context_refiner + self.layers: + block.enable_gradient_checkpointing(activation_cpu_offloading=cpu_offload) + + print(f"Z-Image: Gradient checkpointing enabled. CPU offload: {cpu_offload}") + + def disable_gradient_checkpointing(self): + self.gradient_checkpointing = False + self.activation_cpu_offloading = False + + for block in self.noise_refiner + self.context_refiner + self.layers: + block.disable_gradient_checkpointing() + + print("Z-Image: Gradient checkpointing disabled.") + + def enable_block_swap(self, num_blocks: int, device: torch.device, supports_backward: bool, use_pinned_memory: bool = False): + self.blocks_to_swap = num_blocks + + assert self.blocks_to_swap <= self.num_blocks - 2, ( + f"Cannot swap more than {self.num_blocks - 2} double blocks. Requested {self.blocks_to_swap} double blocks." + ) + + self.offloader = ModelOffloader( + "double", self.layers, len(self.layers), self.blocks_to_swap, supports_backward, device, use_pinned_memory + ) + print( + f"Z-Image: Block swap enabled. Swapping {num_blocks} of {self.num_blocks} blocks to device {device}. Supports backward: {supports_backward}" + ) + + def switch_block_swap_for_inference(self): + if self.blocks_to_swap: + self.offloader.set_forward_only(True) + self.prepare_block_swap_before_forward() + print("Z-Image: Block swap set to forward only.") + + def switch_block_swap_for_training(self): + if self.blocks_to_swap: + self.offloader.set_forward_only(False) + self.prepare_block_swap_before_forward() + print("Z-Image: Block swap set to forward and backward.") + + def move_to_device_except_swap_blocks(self, device: torch.device): + # assume model is on cpu. do not move blocks to device to reduce temporary memory usage + if self.blocks_to_swap: + save_layers = self.layers + self.layers = nn.ModuleList() + + self.to(device) + + if self.blocks_to_swap: + self.layers = save_layers + + def prepare_block_swap_before_forward(self): + if self.blocks_to_swap is None or self.blocks_to_swap == 0: + return + self.offloader.prepare_block_devices_before_forward(self.layers) + + def unpatchify(self, x: torch.Tensor, size: Tuple[int, int, int], patch_size: int, f_patch_size: int) -> torch.Tensor: + """ + Unpatchify the latent tensor back to image/video format. + + Args: + x: [B, seq_len, patch_dim] tensor + size: (F, H, W) tuple of the original latent size + patch_size: spatial patch size (pH = pW) + f_patch_size: temporal patch size (pF) + + Returns: + [B, C, F, H, W] tensor + """ + pH = pW = patch_size + pF = f_patch_size + F_size, H_size, W_size = size + B = x.shape[0] + F_tokens, H_tokens, W_tokens = F_size // pF, H_size // pH, W_size // pW + ori_len = F_tokens * H_tokens * W_tokens + + # Take only the original image tokens (exclude caption part if any) + x = x[:, :ori_len] # [B, ori_len, patch_dim] + + x = x.view(B, F_tokens, H_tokens, W_tokens, pF, pH, pW, self.out_channels) + x = x.permute(0, 7, 1, 4, 2, 5, 3, 6) # [B, C, F_tokens, pF, H_tokens, pH, W_tokens, pW] + x = x.reshape(B, self.out_channels, F_size, H_size, W_size) + return x + + @staticmethod + def create_coordinate_grid(size, start=None, device=None): + if start is None: + start = (0 for _ in size) + axes = [torch.arange(x0, x0 + span, dtype=torch.int32, device=device) for x0, span in zip(start, size)] + grids = torch.meshgrid(axes, indexing="ij") + return torch.stack(grids, dim=-1) + + def patchify(self, x: torch.Tensor, patch_size: int, f_patch_size: int) -> torch.Tensor: + """ + Patchify the latent tensor. + + Args: + x: [B, C, F, H, W] tensor + patch_size: spatial patch size (pH = pW) + f_patch_size: temporal patch size (pF) + + Returns: + [B, seq_len, patch_dim] tensor where seq_len = (F/pF) * (H/pH) * (W/pW) + and patch_dim = pF * pH * pW * C + """ + pH = pW = patch_size + pF = f_patch_size + B, C, F_size, H_size, W_size = x.shape + F_tokens, H_tokens, W_tokens = F_size // pF, H_size // pH, W_size // pW + + x = x.view(B, C, F_tokens, pF, H_tokens, pH, W_tokens, pW) + x = x.permute(0, 2, 4, 6, 3, 5, 7, 1) # [B, F_tokens, H_tokens, W_tokens, pF, pH, pW, C] + x = x.reshape(B, F_tokens * H_tokens * W_tokens, pF * pH * pW * C) + return x + + def create_image_position_ids( + self, F_tokens: int, H_tokens: int, W_tokens: int, cap_seq_len: int, device: torch.device + ) -> torch.Tensor: + """ + Create position IDs for image patches. + + Args: + F_tokens: number of frame tokens + H_tokens: number of height tokens + W_tokens: number of width tokens + cap_seq_len: caption sequence length (for offset) + device: device to create tensor on + + Returns: + [seq_len, 3] tensor of position IDs + """ + # Image positions start after caption positions + # Position format: (cap_seq_len + 1 + f_idx, h_idx, w_idx). [F_tokens * H_tokens * W_tokens, 3] + return self.create_coordinate_grid( + size=(F_tokens, H_tokens, W_tokens), start=(cap_seq_len + 1, 0, 0), device=device + ).flatten(0, 2) + + def create_caption_position_ids(self, cap_seq_len: int, device: torch.device) -> torch.Tensor: + """ + Create position IDs for caption tokens. + + Args: + cap_seq_len: caption sequence length + device: device to create tensor on + + Returns: + [cap_seq_len, 3] tensor of position IDs + """ + # Caption positions: (i + 1, 0, 0) for i in range(cap_seq_len). [cap_seq_len, 3] + return self.create_coordinate_grid(size=(cap_seq_len, 1, 1), start=(1, 0, 0), device=device).flatten(0, 2) + + def forward( + self, + x: torch.Tensor, + t: torch.Tensor, + cap_feats: torch.Tensor, + cap_mask: torch.Tensor, + patch_size: int = 2, + f_patch_size: int = 1, + ) -> torch.Tensor: + """ + Forward pass of the Z-Image Transformer. + + Args: + x: Latent tensor [B, C, F, H, W] + t: Timestep tensor [B] + cap_feats: Caption features [B, cap_seq_len, cap_feat_dim] + cap_mask: Caption mask [B, cap_seq_len], True for valid tokens + patch_size: Spatial patch size (default: 2) + f_patch_size: Temporal patch size (default: 1) + + Returns: + Output tensor [B, C, F, H, W] + """ + assert patch_size in self.all_patch_size + assert f_patch_size in self.all_f_patch_size + + B, C, F_size, H_size, W_size = x.shape + device = x.device + cap_seq_len = cap_feats.shape[1] + + # Timestep embedding + t = t * self.t_scale # 0-1 to 0-1000 + adaln_input = self.t_embedder(t) + + # Patchify and embed x + pH = pW = patch_size + pF = f_patch_size + F_tokens, H_tokens, W_tokens = F_size // pF, H_size // pH, W_size // pW + x_seq_len = F_tokens * H_tokens * W_tokens + + x = self.patchify(x, patch_size, f_patch_size) # [B, x_seq_len, patch_dim] + x = self.all_x_embedder[f"{patch_size}-{f_patch_size}"](x) # [B, x_seq_len, dim] + + adaln_input = adaln_input.type_as(x) + + # Create position IDs and RoPE for x (same for all samples since images have same size) + x_pos_ids = self.create_image_position_ids(F_tokens, H_tokens, W_tokens, cap_seq_len, device) + x_freqs_cis = self.rope_embedder(x_pos_ids) # [x_seq_len, head_dim] + del x_pos_ids + x_freqs_cis = x_freqs_cis.unsqueeze(0).expand(B, -1, -1) # [B, x_seq_len, head_dim] + + # Apply noise refiner + noise_refiner_attn_params = AttentionParams.create_attention_params_from_mask(self.attn_mode, self.split_attn, 0, None) + for layer in self.noise_refiner: + x = layer(x, x_freqs_cis, adaln_input, attn_params=noise_refiner_attn_params) + + # Embed caption features + cap_feats = self.cap_embedder(cap_feats) # [B, cap_seq_len, dim] + + # Apply cap_pad_token to masked positions + if cap_mask is not None: + cap_pad_mask = ~cap_mask # True for padding positions + cap_feats = cap_feats.masked_fill(cap_pad_mask.unsqueeze(-1), 0.0) + cap_feats = cap_feats + self.cap_pad_token * cap_pad_mask.unsqueeze(-1).float() + + # Create position IDs and RoPE for captions + cap_pos_ids = self.create_caption_position_ids(cap_seq_len, device) + cap_freqs_cis = self.rope_embedder(cap_pos_ids) # [cap_seq_len, head_dim] + del cap_pos_ids + cap_freqs_cis = cap_freqs_cis.unsqueeze(0).expand(B, -1, -1) # [B, cap_seq_len, head_dim] + + # Apply context refiner + context_refiner_attn_params = AttentionParams.create_attention_params_from_mask( + self.attn_mode, self.split_attn, 0, cap_mask + ) + for layer in self.context_refiner: + cap_feats = layer(cap_feats, cap_freqs_cis, attn_params=context_refiner_attn_params) + + # Concatenate x and cap_feats for unified processing + # Order: [x tokens, caption tokens] + unified = torch.cat([x, cap_feats], dim=1) # [B, x_seq_len + cap_seq_len, dim] + del x, cap_feats + unified_freqs_cis = torch.cat([x_freqs_cis, cap_freqs_cis], dim=1) # [B, x_seq_len + cap_seq_len, head_dim] + del x_freqs_cis, cap_freqs_cis + + # Apply main transformer layers + attn_params = AttentionParams.create_attention_params_from_mask(self.attn_mode, self.split_attn, x_seq_len, cap_mask) + for index, layer in enumerate(self.layers): + if self.blocks_to_swap: + self.offloader.wait_for_block(index) + + unified = layer(unified, unified_freqs_cis, adaln_input, attn_params=attn_params) + + if self.blocks_to_swap: + self.offloader.submit_move_blocks_forward(self.layers, index) + + unified = unified.to(device) # ensure unified is on the correct device when activation CPU offloading is used + + # Apply final layer + unified = self.all_final_layer[f"{patch_size}-{f_patch_size}"](unified, adaln_input) + + # Unpatchify (takes only the first x_seq_len tokens) + x = self.unpatchify(unified, (F_size, H_size, W_size), patch_size, f_patch_size) + + return x + + +FP8_OPTIMIZATION_TARGET_KEYS = ["layers.", "noise_refiner.", "context_refiner."] +FP8_OPTIMIZATION_EXCLUDE_KEYS = ["_modulation", ".norm_", "_norm"] + + +def create_model( + attn_mode: str, split_attn: bool, dtype: Optional[torch.dtype], use_16bit_for_attention: bool = False +) -> ZImageTransformer2DModel: + with init_empty_weights(): + logger.info("Creating ZImageTransformer2DModel") + model = ZImageTransformer2DModel( + all_patch_size=tuple(zimage_config.DEFAULT_TRANSFORMER_PATCH_SIZE), + all_f_patch_size=tuple(zimage_config.DEFAULT_TRANSFORMER_F_PATCH_SIZE), + in_channels=zimage_config.DEFAULT_TRANSFORMER_IN_CHANNELS, + dim=zimage_config.DEFAULT_TRANSFORMER_DIM, + n_layers=zimage_config.DEFAULT_TRANSFORMER_N_LAYERS, + n_refiner_layers=zimage_config.DEFAULT_TRANSFORMER_N_REFINER_LAYERS, + n_heads=zimage_config.DEFAULT_TRANSFORMER_N_HEADS, + n_kv_heads=zimage_config.DEFAULT_TRANSFORMER_N_KV_HEADS, + norm_eps=zimage_config.DEFAULT_TRANSFORMER_NORM_EPS, + qk_norm=zimage_config.DEFAULT_TRANSFORMER_QK_NORM, + cap_feat_dim=zimage_config.DEFAULT_TRANSFORMER_CAP_FEAT_DIM, + rope_theta=zimage_config.ROPE_THETA, + t_scale=zimage_config.DEFAULT_TRANSFORMER_T_SCALE, + axes_dims=zimage_config.ROPE_AXES_DIMS, + axes_lens=zimage_config.ROPE_AXES_LENS, + attn_mode=attn_mode, + split_attn=split_attn, + use_16bit_for_attention=use_16bit_for_attention, + ) + if dtype is not None: + model.to(dtype) + return model + + +def load_zimage_model( + device: Union[str, torch.device], + dit_path: str, + attn_mode: str, + split_attn: bool, + loading_device: Union[str, torch.device], + dit_weight_dtype: Optional[torch.dtype], + fp8_scaled: bool = False, + lora_weights_list: Optional[Dict[str, torch.Tensor]] = None, + lora_multipliers: Optional[List[float]] = None, + disable_numpy_memmap: bool = False, + use_16bit_for_attention: bool = False, +) -> ZImageTransformer2DModel: + """ + Load a Z-Image model from the specified checkpoint. + + Args: + device (Union[str, torch.device]): Device for optimization or merging + dit_path (str): Path to the DiT model checkpoint. + attn_mode (str): Attention mode to use, e.g., "torch", "flash", etc. + split_attn (bool): Whether to use split attention. + loading_device (Union[str, torch.device]): Device to load the model weights on. + dit_weight_dtype (Optional[torch.dtype]): Data type of the DiT weights. + If None, it will be loaded as is (same as the state_dict) or scaled for fp8. if not None, model weights will be casted to this dtype. + fp8_scaled (bool): Whether to use fp8 scaling for the model weights. + lora_weights_list (Optional[Dict[str, torch.Tensor]]): LoRA weights to apply, if any. + lora_multipliers (Optional[List[float]]): LoRA multipliers for the weights, if any. + disable_numpy_memmap (bool): Whether to disable numpy memory mapping when loading weights. + use_16bit_for_attention (bool): Whether to use 16-bit precision for attention computations. + """ + # dit_weight_dtype is None for fp8_scaled + assert (not fp8_scaled and dit_weight_dtype is not None) or (fp8_scaled and dit_weight_dtype is None) + + device = torch.device(device) + loading_device = torch.device(loading_device) + + model = create_model(attn_mode, split_attn, dit_weight_dtype, use_16bit_for_attention=use_16bit_for_attention) + + replace_keys = { + "all_final_layer.2-1.linear": "final_layer.linear", + "all_final_layer.2-1.adaLN_modulation": "final_layer.adaLN_modulation", + "all_x_embedder.2-1.bias": "x_embedder.bias", + "all_x_embedder.2-1.weight": "x_embedder.weight", + ".attention.to_out.0.bias": ".attention.out.bias", + ".attention.norm_k.weight": ".attention.k_norm.weight", + ".attention.norm_q.weight": ".attention.q_norm.weight", + ".attention.to_out.0.weight": ".attention.out.weight", + } + replace_keys_reverse = {v: k for k, v in replace_keys.items()} + + def comfyui_z_image_weight_split_hook( + key: str, value: Optional[torch.Tensor] + ) -> Tuple[Optional[list[str]], Optional[list[torch.Tensor]]]: + # Use split hook for key conversion + for k, v in replace_keys_reverse.items(): + if k in key: + key = key.replace(k, v) + return [key], [value] if value is not None else None + + # convert to separate Q, K, V weights/biases + if "attention.qkv.weight" in key: + new_keys = [key.replace("qkv", module) for module in ["to_q", "to_k", "to_v"]] + return new_keys, list(torch.chunk(value, 3, dim=0)) if value is not None else None + + return None, None + + hooks = WeightTransformHooks(split_hook=comfyui_z_image_weight_split_hook) + + # load model weights with dynamic fp8 optimization and LoRA merging if needed + logger.info(f"Loading DiT model from {dit_path}, device={loading_device}") + sd = load_safetensors_with_lora_and_fp8( + model_files=dit_path, + lora_weights_list=lora_weights_list, + lora_multipliers=lora_multipliers, + fp8_optimization=fp8_scaled, + calc_device=device, + move_to_device=(loading_device == device), + dit_weight_dtype=dit_weight_dtype, + target_keys=FP8_OPTIMIZATION_TARGET_KEYS, + exclude_keys=FP8_OPTIMIZATION_EXCLUDE_KEYS, + disable_numpy_memmap=disable_numpy_memmap, + weight_transform_hooks=hooks, + ) + + # TODO cast weights to mixed precision dtype when fp8_scaled is True, and original weights are in fp32 + + if fp8_scaled: + apply_fp8_monkey_patch(model, sd, use_scaled_mm=False) + + if loading_device.type != "cpu": + # make sure all the model weights are on the loading_device + logger.info(f"Moving weights to {loading_device}") + for key in sd.keys(): + sd[key] = sd[key].to(loading_device) + + info = model.load_state_dict(sd, strict=True, assign=True) + logger.info(f"Loaded DiT model from {dit_path}, info={info}") + + return model diff --git a/src/musubi_tuner/zimage/zimage_utils.py b/src/musubi_tuner/zimage/zimage_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..a238872faf1ead331174ab5f2a7e7dd234b84871 --- /dev/null +++ b/src/musubi_tuner/zimage/zimage_utils.py @@ -0,0 +1,282 @@ +import json +import math +from typing import Optional, Union +import logging + +import numpy as np +import torch +from transformers import Qwen3Config, Qwen3ForCausalLM, Qwen2Tokenizer +from accelerate import init_empty_weights + +from musubi_tuner.utils.safetensors_utils import load_split_weights +from musubi_tuner.zimage import zimage_config + +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) + + +ZIMAGE_ID = "Tongyi-MAI/Z-Image" + + +def shift_scale_latents_for_decode(latents: torch.Tensor) -> torch.Tensor: + """Shift and scale latents before decoding with the VAE. latents should be casted to float32 before calling this function.""" + latents = (latents / zimage_config.ZIMAGE_VAE_SCALING_FACTOR) + zimage_config.ZIMAGE_VAE_SHIFT_FACTOR + return latents + + +def load_qwen3( + ckpt_path: str, + dtype: Optional[torch.dtype], + device: Union[str, torch.device], + disable_mmap: bool = False, + state_dict: Optional[dict] = None, + is_8b: bool = False, + tokenizer_id: Optional[str] = None, +) -> tuple[Qwen2Tokenizer, Qwen3ForCausalLM]: + """Load Qwen3-4B/8B model and tokenizer from checkpoint.""" + QWEN3_4B_CONFIG_JSON = """ +{ + "architectures": [ + "Qwen3ForCausalLM" + ], + "attention_bias": false, + "attention_dropout": 0.0, + "bos_token_id": 151643, + "eos_token_id": 151645, + "head_dim": 128, + "hidden_act": "silu", + "hidden_size": 2560, + "initializer_range": 0.02, + "intermediate_size": 9728, + "max_position_embeddings": 40960, + "max_window_layers": 36, + "model_type": "qwen3", + "num_attention_heads": 32, + "num_hidden_layers": 36, + "num_key_value_heads": 8, + "rms_norm_eps": 1e-06, + "rope_scaling": null, + "rope_theta": 1000000, + "sliding_window": null, + "tie_word_embeddings": true, + "torch_dtype": "bfloat16", + "transformers_version": "4.51.0", + "use_cache": true, + "use_sliding_window": false, + "vocab_size": 151936 +} +""" + + QWEN3_8B_CONFIG_JSON = """ +{ + "architectures": [ + "Qwen3ForCausalLM" + ], + "attention_bias": false, + "attention_dropout": 0.0, + "bos_token_id": 151643, + "eos_token_id": 151645, + "head_dim": 128, + "hidden_act": "silu", + "hidden_size": 4096, + "initializer_range": 0.02, + "intermediate_size": 12288, + "max_position_embeddings": 40960, + "max_window_layers": 36, + "model_type": "qwen3", + "num_attention_heads": 32, + "num_hidden_layers": 36, + "num_key_value_heads": 8, + "rms_norm_eps": 1e-06, + "rope_scaling": null, + "rope_theta": 1000000, + "sliding_window": null, + "tie_word_embeddings": false, + "torch_dtype": "bfloat16", + "transformers_version": "4.51.0", + "use_cache": true, + "use_sliding_window": false, + "vocab_size": 151936 +} +""" + + config = json.loads(QWEN3_8B_CONFIG_JSON if is_8b else QWEN3_4B_CONFIG_JSON) + config = Qwen3Config(**config) + with init_empty_weights(): + qwen3 = Qwen3ForCausalLM._from_config(config) + + if state_dict is not None: + sd = state_dict + else: + logger.info(f"Loading state dict from {ckpt_path}") + sd = load_split_weights(ckpt_path, device=str(device), disable_mmap=disable_mmap, dtype=dtype) + + sd["lm_head.weight"] = sd["model.embed_tokens.weight"] # tie weights + + info = qwen3.load_state_dict(sd, strict=True, assign=True) + logger.info(f"Loaded Qwen3: {info}") + qwen3.to(device) + + if dtype is not None: + if dtype.itemsize == 1: # torch.float8 + # prepare Qwen3 for fp8 + org_dtype = torch.bfloat16 # model weight is fp8 in loading, but original dtype is bfloat16 + logger.info(f"prepare Qwen3 for fp8: set to {dtype} from {org_dtype}") + qwen3.to(dtype) + + # prepare LLM for fp8 + def prepare_fp8(vl_model: Qwen3ForCausalLM, target_dtype): + def rms_norm_forward_hook(module): + def forward(hidden_states): + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + variance = hidden_states.pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + module.variance_epsilon) + # return module.weight.to(input_dtype) * hidden_states.to(input_dtype) + return (module.weight.to(torch.float32) * hidden_states.to(torch.float32)).to(input_dtype) + + return forward + + for module in vl_model.modules(): + if module.__class__.__name__ in ["Embedding"]: + # print("set", module.__class__.__name__, "to", target_dtype) + module.to(target_dtype) + if module.__class__.__name__ in ["Qwen3RMSNorm"]: + # print("set", module.__class__.__name__, "hooks") + module.forward = rms_norm_forward_hook(module) + + prepare_fp8(qwen3, org_dtype) + + else: + logger.info(f"Setting Qwen3 to dtype: {dtype}") + qwen3.to(dtype) + # Load tokenizer + # TODO change to specific tokenizer class + subfolder = None + if tokenizer_id is None: + tokenizer_id = ZIMAGE_ID + subfolder = "tokenizer" + logger.info(f"Loading tokenizer from {tokenizer_id}") + tokenizer = Qwen2Tokenizer.from_pretrained(tokenizer_id, subfolder=subfolder) + return tokenizer, qwen3 + + +def get_text_embeds( + tokenizer: Qwen2Tokenizer, + text_encoder: Qwen3ForCausalLM, + prompt: Union[list[str], str], +) -> tuple[torch.Tensor, torch.Tensor]: + """ + Get text embeddings from the text encoder. + Applies chat template to each prompt before encoding. + + Args: + tokenizer (Qwen2Tokenizer): The tokenizer to use. + text_encoder (Qwen3ForCausalLM): The text encoder model. + prompt (list[str] | str): The input prompt(s). + + Returns: + tuple[torch.Tensor, torch.Tensor]: A tuple containing the prompt embeddings and attention masks. + """ + prompt = [prompt] if isinstance(prompt, str) else prompt + + # logger.info(f"Encoding prompts: {prompt}. Applying chat template.") + formatted_prompts = [] + for p in prompt: + messages = [{"role": "user", "content": p}] + formatted_prompt = tokenizer.apply_chat_template( + messages, + tokenize=False, + add_generation_prompt=True, + enable_thinking=True, + ) + formatted_prompts.append(formatted_prompt) + + text_inputs = tokenizer( + formatted_prompts, + padding="max_length", + max_length=zimage_config.DEFAULT_MAX_SEQUENCE_LENGTH, + truncation=True, + return_tensors="pt", + ) + + text_input_ids = text_inputs.input_ids.to(text_encoder.device) + prompt_masks = text_inputs.attention_mask.to(text_encoder.device).bool() + + with torch.no_grad(): + text_encoder_params = text_encoder.parameters() + text_encoder_params.__next__() # skip first param (embedding) + second_param = text_encoder_params.__next__() + if second_param.dtype.itemsize == 1: # torch.float8 + with torch.autocast(device_type=text_encoder.device.type, dtype=torch.bfloat16): + prompt_embeds = text_encoder( + input_ids=text_input_ids, attention_mask=prompt_masks, output_hidden_states=True + ).hidden_states[-2] + else: + prompt_embeds = text_encoder( + input_ids=text_input_ids, attention_mask=prompt_masks, output_hidden_states=True + ).hidden_states[-2] + return prompt_embeds, prompt_masks + + +def trim_pad_embeds_and_mask( + image_length: int, prompt_embeds: torch.Tensor, prompt_masks: torch.Tensor +) -> tuple[torch.Tensor, torch.Tensor]: + """ + Trim and pad embeddings and masks to the divisible of SEQ_MULTI_OF according to the maximum image and text length. + If the batch size is 1, this function will trim the embeddings and masks to the actual text length without padding. + """ + if prompt_embeds.shape[0] == 1: + actual_text_length = int(prompt_masks.sum(dim=1).item()) + prompt_embeds = prompt_embeds[:, :actual_text_length, :] + prompt_masks = prompt_masks[:, :actual_text_length] + return prompt_embeds, prompt_masks + + max_text_length = prompt_masks.sum(dim=1).max().item() + total_length = image_length + max_text_length + padded_total_length = math.ceil(total_length / zimage_config.SEQ_MULTI_OF) * zimage_config.SEQ_MULTI_OF + pad_length = padded_total_length - total_length + max_text_length += pad_length + if max_text_length > prompt_embeds.shape[1]: + # pad + pad_size = max_text_length - prompt_embeds.shape[1] + pad_embeds = torch.zeros( + (prompt_embeds.shape[0], pad_size, prompt_embeds.shape[2]), dtype=prompt_embeds.dtype, device=prompt_embeds.device + ) + prompt_embeds = torch.cat([prompt_embeds, pad_embeds], dim=1) + pad_masks = torch.zeros((prompt_masks.shape[0], pad_size), dtype=prompt_masks.dtype, device=prompt_masks.device) + prompt_masks = torch.cat([prompt_masks, pad_masks], dim=1) + else: + # trim + prompt_embeds = prompt_embeds[:, :max_text_length, :] + prompt_masks = prompt_masks[:, :max_text_length] + return prompt_embeds, prompt_masks + + +def get_timesteps_sigmas(num_inference_steps: int, shift: float) -> tuple[torch.Tensor, torch.Tensor]: + """Retrieve timesteps based on Z-Image's sigma schedule with shift.""" + num_train_timesteps = zimage_config.DEFAULT_SCHEDULER_NUM_TRAIN_TIMESTEPS + timesteps = np.linspace(num_train_timesteps, 1, num_inference_steps + 1)[:-1] + sigmas = timesteps / num_train_timesteps # 0-1 range + + sigmas = shift * sigmas / (1 + (shift - 1) * sigmas) + timesteps = sigmas * num_train_timesteps + + timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32) + sigmas = torch.from_numpy(sigmas).to(dtype=torch.float32) + sigmas = torch.cat([sigmas, torch.zeros(1, dtype=sigmas.dtype, device=sigmas.device)], dim=0) # add final sigma 0 + + return timesteps, sigmas + + +def step(model_output: torch.Tensor, sample: torch.Tensor, sigmas: torch.Tensor, step_index: int) -> torch.Tensor: + """Predict the sample at the previous timestep.""" + sample = sample.to(torch.float32) + sigma_idx = step_index + sigma = sigmas[sigma_idx] + sigma_next = sigmas[sigma_idx + 1] + + dt = sigma_next - sigma + prev_sample = sample + dt * model_output + prev_sample = prev_sample.to(model_output.dtype) + return prev_sample