diffsynth 2.0.17__tar.gz → 2.0.18__tar.gz

{diffsynth-2.0.17 → diffsynth-2.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffsynth
-Version: 2.0.17
+Version: 2.0.18
 Summary: Enjoy the magic of Diffusion models!
 Author: ModelScope Team
 License: Apache-2.0

{diffsynth-2.0.17 → diffsynth-2.0.18}/README.md

@@ -14,6 +14,8 @@
 ## Introduction
 
 > DiffSynth-Studio Documentation: [中文版](https://diffsynth-studio-doc.readthedocs.io/zh-cn/latest/)、[English version](https://diffsynth-studio-doc.readthedocs.io/en/latest/)
+> 
+> DiffSynth-Studio Skills：[DiffSynth-Studio Model Integration Skills](https://www.modelscope.cn/collections/DiffSynth-Studio/DiffSynth-Studio-Model-Integration-Skills)
 
 Welcome to the magical world of Diffusion models! DiffSynth-Studio is an open-source Diffusion model engine developed and maintained by the [ModelScope Community](https://www.modelscope.cn/). We hope to foster technological innovation through framework construction, aggregate the power of the open-source community, and explore the boundaries of generative model technology!
 
@@ -34,6 +36,8 @@ We believe that a well-developed open-source code framework can lower the thresh
 
 > Currently, the development personnel of this project are limited, with most of the work handled by [Artiprocher](https://github.com/Artiprocher) and [mi804](https://github.com/mi804). Therefore, the progress of new feature development will be relatively slow, and the speed of responding to and resolving issues is limited. We apologize for this and ask developers to understand.
 
+- **July 21, 2026** We have open-sourced [DiffSynth-Studio Model Integration Skills](https://www.modelscope.cn/collections/DiffSynth-Studio/DiffSynth-Studio-Model-Integration-Skills). This is a composable collection of Agent Skills that automates the entire workflow of integrating external diffusion models into DiffSynth-Studio, significantly improving the standardization and efficiency of model integration. Get started with the [example](https://www.modelscope.cn/skills/DiffSynth-Studio/diffsynth-integrator/file/view/master/example.md?status=1)!
+
 - **June 29, 2026** Boogu-Image open-sourced. Support includes text-to-image generation, image editing, low VRAM inference, and training capabilities. For details, please refer to the [documentation](/docs/en/Model_Details/Boogu-Image.md) and [example code](/examples/boogu_image/).
 
 - **June 24, 2026** Krea-2 is now open-source, and we have provided full support. For more details, please refer to the [documentation](/docs/en/Model_Details/Krea-2.md) and [example code](/examples/krea2/).

{diffsynth-2.0.17 → diffsynth-2.0.18}/diffsynth/configs/vram_management_module_maps.py

@@ -307,21 +307,18 @@ VRAM_MANAGEMENT_MODULE_MAPS = {
         "torch.nn.Conv1d": "diffsynth.core.vram.layers.AutoWrappedModule",
         "torch.nn.ConvTranspose1d": "diffsynth.core.vram.layers.AutoWrappedModule",
         "transformers.models.qwen3.modeling_qwen3.Qwen3RMSNorm": "diffsynth.core.vram.layers.AutoWrappedModule",
-        "transformers.models.qwen3.modeling_qwen3.Qwen3MLP": "diffsynth.core.vram.layers.AutoWrappedModule",
         "transformers.models.qwen3.modeling_qwen3.Qwen3RotaryEmbedding": "diffsynth.core.vram.layers.AutoWrappedModule",
     },
     "diffsynth.models.ace_step_conditioner.AceStepConditionEncoder": {
         "torch.nn.Linear": "diffsynth.core.vram.layers.AutoWrappedLinear",
         "torch.nn.Embedding": "diffsynth.core.vram.layers.AutoWrappedModule",
         "transformers.models.qwen3.modeling_qwen3.Qwen3RMSNorm": "diffsynth.core.vram.layers.AutoWrappedModule",
-        "transformers.models.qwen3.modeling_qwen3.Qwen3MLP": "diffsynth.core.vram.layers.AutoWrappedModule",
         "transformers.models.qwen3.modeling_qwen3.Qwen3RotaryEmbedding": "diffsynth.core.vram.layers.AutoWrappedModule",
     },
     "diffsynth.models.ace_step_text_encoder.AceStepTextEncoder": {
         "torch.nn.Linear": "diffsynth.core.vram.layers.AutoWrappedLinear",
         "torch.nn.Embedding": "diffsynth.core.vram.layers.AutoWrappedModule",
         "transformers.models.qwen3.modeling_qwen3.Qwen3RMSNorm": "diffsynth.core.vram.layers.AutoWrappedModule",
-        "transformers.models.qwen3.modeling_qwen3.Qwen3MLP": "diffsynth.core.vram.layers.AutoWrappedModule",
         "transformers.models.qwen3.modeling_qwen3.Qwen3RotaryEmbedding": "diffsynth.core.vram.layers.AutoWrappedModule",
     },
     "diffsynth.models.ace_step_vae.AceStepVAE": {

{diffsynth-2.0.17 → diffsynth-2.0.18}/diffsynth/models/ace_step_vae.py

@@ -259,14 +259,116 @@ class AceStepVAE(nn.Module):
         )
         self.sampling_rate = sampling_rate
 
-    def encode(self, x: torch.Tensor) -> torch.Tensor:
-        """Audio waveform [B, audio_channels, T] → latent [B, decoder_input_channels, T']."""
+    def tiled_encode(self, x: torch.Tensor, tile_size: int = 10240, tile_stride: int = 5120) -> torch.Tensor:
+        batch_size, audio_channels, T_audio = x.shape
+        up = self.upsampling_factor
+
+        lat_T = round(T_audio / up)
+
+        tiles = []
+        for t in range(0, T_audio, tile_stride):
+            if t - tile_stride >= 0 and t - tile_stride + tile_size >= T_audio:
+                continue
+            tiles.append((t, min(t + tile_size, T_audio)))
+
+        encoder_out_channels = self.encoder.conv2.out_channels
+        values = torch.zeros((batch_size, encoder_out_channels, lat_T), dtype=x.dtype, device="cpu")
+        weight = torch.zeros((1, 1, lat_T), dtype=x.dtype, device="cpu")
+
+        for t_start, t_end in tiles:
+            tile_audio = x[:, :, t_start:t_end]
+            tile_latent = self.encoder(tile_audio).to("cpu")
+            lat_len = tile_latent.shape[-1]
+
+            lat_start = round(t_start / up)
+            lat_end = lat_start + lat_len
+
+            border = (tile_size - tile_stride) // up
+            mask = self._build_blend_mask_1d(
+                lat_len, border,
+                is_left_bound=(t_start == 0),
+                is_right_bound=(t_end >= T_audio),
+                dtype=x.dtype, device="cpu",
+            )
+
+            values[:, :, lat_start:lat_end] += tile_latent * mask
+            weight[:, :, lat_start:lat_end] += mask
+
+        weight = weight.clamp(min=1e-8)
+        latent = values / weight
+        output = OobleckDiagonalGaussianDistribution(latent.to(x.device)).sample()
+        return output
+
+    def encode(self, x: torch.Tensor, tiled: bool = False, tile_size: int = 10240, tile_stride: int = 5120) -> torch.Tensor:
+        """Audio waveform [B, audio_channels, T] → latent [B, decoder_input_channels, T"]."""
+        if tiled:
+            return self.tiled_encode(x, tile_size=tile_size, tile_stride=tile_stride)
         h = self.encoder(x)
         output = OobleckDiagonalGaussianDistribution(h).sample()
         return output
 
-    def decode(self, z: torch.Tensor) -> torch.Tensor:
-        """Latent [B, decoder_input_channels, T] → audio waveform [B, audio_channels, T']."""
+    @property
+    def upsampling_factor(self) -> int:
+        ratios = [10, 6, 4, 4, 2]
+        result = 1
+        for r in ratios:
+            result *= r
+        return result
+
+    def _build_blend_mask_1d(self, length: int, border_width: int, is_left_bound: bool, is_right_bound: bool,
+                              dtype: torch.dtype, device: torch.device) -> torch.Tensor:
+        mask = torch.ones(length, dtype=dtype, device=device)
+        if border_width <= 0:
+            return mask
+        if not is_left_bound:
+            ramp = torch.linspace(0.0, 1.0, border_width, dtype=dtype, device=device)
+            mask[:border_width] = ramp
+        if not is_right_bound:
+            ramp = torch.linspace(1.0, 0.0, border_width, dtype=dtype, device=device)
+            mask[-border_width:] = ramp
+        return mask.unsqueeze(0).unsqueeze(0)
+
+    def tiled_decode(self, z: torch.Tensor, tile_size: int = 512, tile_stride: int = 256) -> torch.Tensor:
+        batch_size, channels, T = z.shape
+        up = self.upsampling_factor
+        out_length = up * T
+
+        tiles = []
+        for t in range(0, T, tile_stride):
+            if t - tile_stride >= 0 and t - tile_stride + tile_size >= T:
+                continue
+            tiles.append((t, min(t + tile_size, T)))
+
+        audio_channels = self.decoder.conv2.out_channels
+        values = torch.zeros((batch_size, audio_channels, out_length), dtype=z.dtype, device="cpu")
+        weight = torch.zeros((1, 1, out_length), dtype=z.dtype, device="cpu")
+
+        for t_start, t_end in tiles:
+            tile_latent = z[:, :, t_start:t_end]
+            tile_output = self.decoder(tile_latent).to("cpu")
+            tile_len = tile_output.shape[-1]
+
+            out_start = t_start * up
+            out_end = out_start + tile_len
+
+            border = (tile_size - tile_stride) * up
+            mask = self._build_blend_mask_1d(
+                tile_len, border,
+                is_left_bound=(t_start == 0),
+                is_right_bound=(t_end >= T),
+                dtype=z.dtype, device="cpu",
+            )
+
+            values[:, :, out_start:out_end] += tile_output * mask
+            weight[:, :, out_start:out_end] += mask
+
+        weight = weight.clamp(min=1e-8)
+        return values / weight
+
+    def decode(self, z: torch.Tensor, tiled: bool = False, tile_size: int = 512, tile_stride: int = 256) -> torch.Tensor:
+        """Latent [B, decoder_input_channels, T] → audio waveform [B, audio_channels, T]."""
+        if tiled:
+            return self.tiled_decode(z, tile_size=tile_size, tile_stride=tile_stride)
         return self.decoder(z)
 
     def forward(self, sample: torch.Tensor) -> torch.Tensor:

{diffsynth-2.0.17 → diffsynth-2.0.18}/diffsynth/pipelines/ace_step.py

@@ -125,6 +125,10 @@ class AceStepPipeline(BasePipeline):
         # Residual
         residual = None,
         negative_residual = None,
+        # Tiled VAE
+        tiled: bool = False,
+        tile_size: int = 512,
+        tile_stride: int = 256,
         # Progress
         progress_bar_cmd=tqdm,
     ):
@@ -173,21 +177,17 @@ class AceStepPipeline(BasePipeline):
 
         # Decode
         self.load_models_to_device(['vae'])
-        # DiT output is [B, T, 64] (channels-last), VAE expects [B, 64, T] (channels-first)
-        latents = inputs_shared["latents"].transpose(1, 2)
-        vae_output = self.vae.decode(latents)
-        audio_output = self.normalize_audio(vae_output, target_db=-1.0)
-        audio = self.output_audio_format_check(audio_output)
+        audio = self.vae_output_to_audio(inputs_shared["latents"], tiled, tile_size, tile_stride)
         self.load_models_to_device([])
         return audio
-
-    def normalize_audio(self, audio: torch.Tensor, target_db: float = -1.0) -> torch.Tensor:
+    
+    def vae_output_to_audio(self, vae_output, tiled=False, tile_size=512, tile_stride=256):
+        audio = self.vae.decode(vae_output.transpose(1, 2), tiled=tiled, tile_size=tile_size, tile_stride=tile_stride)
         peak = torch.max(torch.abs(audio))
-        if peak < 1e-6:
-            return audio
-        target_amp = 10 ** (target_db / 20.0)
-        gain = target_amp / peak
-        return audio * gain
+        if peak < 1e-6: return audio
+        audio = audio * (10 ** (-1 / 20.0) / peak)
+        audio = self.output_audio_format_check(audio)
+        return audio
 
     def switch_noncover_condition(self, inputs_shared, inputs_posi, inputs_nega, progress_id):
         if inputs_shared["task_type"] != "cover" or inputs_shared["audio_cover_strength"] >= 1.0:

{diffsynth-2.0.17 → diffsynth-2.0.18}/diffsynth.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffsynth
-Version: 2.0.17
+Version: 2.0.18
 Summary: Enjoy the magic of Diffusion models!
 Author: ModelScope Team
 License: Apache-2.0

{diffsynth-2.0.17 → diffsynth-2.0.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "diffsynth"
-version = "2.0.17"
+version = "2.0.18"
 description = "Enjoy the magic of Diffusion models!"
 authors = [{name = "ModelScope Team"}]
 license = {text = "Apache-2.0"}