Use multiple-of-16 resolutions for all models #2436

* was already the case for Flux/SD3
* other models used 8 which was their latent downscale factor, but profit from 16 to avoid border artifacts

Author: Acly

ai_diffusion/model.py

@@ -16,7 +16,7 @@
 from PyQt5.QtCore import QMetaObject, QObject, Qt, QUuid, pyqtSignal
 from PyQt5.QtGui import QBrush, QColor, QPainter
 
-from . import eventloop, util, workflow
+from . import eventloop, resolution, util, workflow
 from .api import (
     ConditioningInput,
     ControlInput,
@@ -1559,14 +1559,11 @@ def get_selection_modifiers(
         feather = min(feather, 0.01)
         invert = True
 
-    if isinstance(arch, InpaintContext):
-        if arch is InpaintContext.mask_bounds:
-            min_size = 0
-            multiple = 1
-        else:
-            multiple = 8
+    if arch is InpaintContext.mask_bounds:
+        min_size = 0
+        multiple = 1
     else:
-        multiple = arch.latent_compression_factor
+        multiple = resolution.diffusion_multiple
 
     return SelectionModifiers(
         feather_rel=feather * strength,

ai_diffusion/resolution.py

@@ -133,6 +133,11 @@ def target_scaling(self):
             return ScaleMode.resize
 
 
+# Image resolution for diffusion should be divisible by this factor, either because it is the
+# required latent compression factor, or to avoid border artifacts with UNET models.
+diffusion_multiple = 16
+
+
 class CheckpointResolution(NamedTuple):
     """Preferred resolution for a SD checkpoint, typically the resolution it was trained on."""
 
@@ -156,7 +161,7 @@ def compute(extent: Extent, arch: Arch, style: Style | None = None, inpaint=Fals
                 default = (640, 1280, 512**2, 1024**2)
             min_size, max_size, min_pixel_count, max_pixel_count = res.get(arch, default)
         else:
-            range_offset = multiple_of(round(0.2 * style.preferred_resolution), 8)
+            range_offset = multiple_of(round(0.2 * style.preferred_resolution), diffusion_multiple)
             min_size = style.preferred_resolution - range_offset
             max_size = style.preferred_resolution + range_offset
             min_pixel_count = max_pixel_count = style.preferred_resolution**2
@@ -186,7 +191,6 @@ def prepare_diffusion_input(
     desired = apply_resolution_settings(extent, perf)
 
     # The checkpoint may require a different resolution than what is requested.
-    mult = arch.latent_compression_factor
     if arch.is_edit:
         downscale = False  # Never use 2-pass generation for edit models
 
@@ -197,8 +201,8 @@ def prepare_diffusion_input(
     if downscale and max_scale < 0.9 and any(x > max_size for x in desired):
         # Desired resolution is significantly larger than the maximum size. Do 2 passes:
         # first pass at checkpoint resolution, then upscale to desired resolution and refine.
-        input = initial = (desired * max_scale).multiple_of(mult)
-        desired = desired.multiple_of(mult)
+        input = initial = (desired * max_scale).multiple_of(diffusion_multiple)
+        desired = desired.multiple_of(diffusion_multiple)
         # Input images are scaled down here for the initial pass directly to avoid encoding
         # and processing large images in subsequent steps.
         image = Image.scale(image, initial) if image else None
@@ -209,13 +213,13 @@ def prepare_diffusion_input(
         scaled = desired * min_scale
         # Avoid unnecessary scaling if too small resolution is caused by resolution multiplier
         if all(x >= min_size and x <= max_size for x in extent):
-            initial = desired = extent.multiple_of(mult)
+            initial = desired = extent.multiple_of(diffusion_multiple)
         else:
-            initial = desired = scaled.multiple_of(mult)
+            initial = desired = scaled.multiple_of(diffusion_multiple)
 
     else:  # Desired resolution is in acceptable range. Do 1 pass at desired resolution.
         input = extent
-        initial = desired = desired.multiple_of(mult)
+        initial = desired = desired.multiple_of(diffusion_multiple)
 
     # Scale down input images if needed due to resolution_multiplier or max_pixel_count
     if extent.pixel_count > desired.pixel_count:

ai_diffusion/resources.py

@@ -241,10 +241,6 @@ def text_encoders(self):
                 return ["qwen_3_4b"]
         raise ValueError(f"Unsupported architecture: {self}")
 
-    @property
-    def latent_compression_factor(self):
-        return 16 if self.is_flux2 or self is Arch.sd3 else 8
-
     @staticmethod
     def list():
         return [

ai_diffusion/workflow.py

@@ -1327,7 +1327,7 @@ def upscale_tiled(
     models: ModelDict,
 ):
     upscale_factor = extent.initial.width / extent.input.width
-    multiple = models.arch.latent_compression_factor
+    multiple = resolution.diffusion_multiple
     if upscale.tile_overlap >= 0:
         layout = TileLayout(extent.initial, extent.desired.width, upscale.tile_overlap, multiple)
     else:
@@ -1714,9 +1714,9 @@ def prepare(
         else:
             tile_size = 1024
         tile_size = max(tile_size, target_extent.longest_side // 12)  # max 12x12 tiles total
-        tile_size = multiple_of(tile_size - 128, arch.latent_compression_factor)
+        tile_size = multiple_of(tile_size - 128, resolution.diffusion_multiple)
         tile_size = Extent(tile_size, tile_size)
-        initial_extent = target_extent.multiple_of(arch.latent_compression_factor)
+        initial_extent = target_extent.multiple_of(resolution.diffusion_multiple)
         extent = ExtentInput(canvas.extent, initial_extent, tile_size, target_extent)
         i.images = ImageInput(extent, canvas)
         assert upscale is not None

tests/test_resolution.py

@@ -126,9 +126,9 @@ def test_inpaint_context(area, expected_extent, expected_crop: tuple[int, int] |
 @pytest.mark.parametrize(
     "input,expected_initial,expected_desired",
     [
-        (Extent(1536, 600), Extent(1008, 392), Extent(1536, 600)),
+        (Extent(1536, 600), Extent(1008, 400), Extent(1536, 608)),
         (Extent(400, 1024), Extent(400, 1024), Extent(400, 1024)),
-        (Extent(777, 999), Extent(560, 712), Extent(784, 1000)),
+        (Extent(777, 999), Extent(560, 720), Extent(784, 1008)),
     ],
 )
 def test_prepare_highres(input, expected_initial, expected_desired):
@@ -144,20 +144,20 @@ def test_prepare_highres(input, expected_initial, expected_desired):
     )
 
 
-def test_prepare_hightres_inpaint():
-    input = Extent(3000, 2000)
+def test_prepare_highres_inpaint():
+    input = Extent(3008, 2000)
     image = Image.create(input)
     r, _ = resolution.prepare_image(image, Arch.flux, dummy_style, perf, inpaint=True)
-    assert r.extent.initial == Extent(1256, 840)
+    assert r.extent.initial == Extent(1264, 848)
     assert r.extent.desired == input
 
 
 @pytest.mark.parametrize(
     "input,expected",
     [
         (Extent(256, 256), Extent(512, 512)),
-        (Extent(128, 450), Extent(280, 960)),
-        (Extent(256, 333), Extent(456, 584)),  # multiple of 8
+        (Extent(128, 450), Extent(288, 960)),
+        (Extent(256, 333), Extent(464, 592)),  # multiple of 16
     ],
 )
 def test_prepare_lowres(input: Extent, expected: Extent):
@@ -174,7 +174,7 @@ def test_prepare_lowres(input: Extent, expected: Extent):
 
 @pytest.mark.parametrize(
     "input",
-    [Extent(512, 512), Extent(128, 600), Extent(768, 240)],
+    [Extent(512, 512), Extent(128, 608), Extent(768, 240)],
 )
 def test_prepare_passthrough(input: Extent):
     image = Image.create(input)
@@ -190,23 +190,23 @@ def test_prepare_passthrough(input: Extent):
 
 
 @pytest.mark.parametrize(
-    "input,expected", [(Extent(512, 513), Extent(512, 520)), (Extent(300, 1024), Extent(304, 1024))]
+    "input,expected", [(Extent(512, 513), Extent(512, 528)), (Extent(300, 1024), Extent(304, 1024))]
 )
-def test_prepare_multiple8(input: Extent, expected: Extent):
+def test_prepare_multiple16(input: Extent, expected: Extent):
     r, _ = resolution.prepare_extent(input, Arch.sd15, dummy_style, perf)
     assert (
         r.extent.input == input
         and r.extent.initial == expected
         and r.extent.target == input
-        and r.extent.desired == input.multiple_of(8)
+        and r.extent.desired == input.multiple_of(16)
     )
 
 
 @pytest.mark.parametrize("sdver", [Arch.sd15, Arch.sdxl])
 def test_prepare_extent(sdver: Arch):
     input = Extent(1024, 1536)
     r, _ = resolution.prepare_extent(input, sdver, dummy_style, perf)
-    expected = Extent(512, 768) if sdver == Arch.sd15 else Extent(840, 1256)
+    expected = Extent(512, 768) if sdver == Arch.sd15 else Extent(848, 1264)
     assert r.extent.initial == expected and r.extent.desired == input and r.extent.target == input
 
 
@@ -228,20 +228,20 @@ def test_prepare_no_downscale(input: Extent):
     assert (
         r.initial_image
         and r.initial_image == image
-        and r.extent.initial == input.multiple_of(8)
-        and r.extent.desired == input.multiple_of(8)
+        and r.extent.initial == input.multiple_of(16)
+        and r.extent.desired == input.multiple_of(16)
         and r.extent.target == input
     )
 
 
 @pytest.mark.parametrize(
     "sd_ver,input,expected_initial,expected_desired",
     [
-        (Arch.sd15, Extent(2000, 2000), (632, 632), (1000, 1000)),
-        (Arch.sd15, Extent(1000, 1000), (632, 632), (1000, 1000)),
+        (Arch.sd15, Extent(2000, 2000), (640, 640), (1008, 1008)),
+        (Arch.sd15, Extent(1000, 1000), (640, 640), (1008, 1008)),
         (Arch.sdxl, Extent(1024, 1024), (1024, 1024), (1024, 1024)),
-        (Arch.sdxl, Extent(2000, 2000), (1000, 1000), (1000, 1000)),
-        (Arch.sd15, Extent(801, 801), (632, 632), (808, 808)),
+        (Arch.sdxl, Extent(2000, 2000), (1008, 1008), (1008, 1008)),
+        (Arch.sd15, Extent(801, 801), (640, 640), (816, 816)),
     ],
     ids=["sd15_large", "sd15_small", "sdxl_small", "sdxl_large", "sd15_odd"],
 )
@@ -260,11 +260,11 @@ def test_prepare_max_pixel_count(input, sd_ver, expected_initial, expected_desir
     [
         (Extent(512, 512), 1.0, Extent(512, 512), Extent(512, 512)),
         (Extent(1024, 800), 0.5, Extent(512, 400), Extent(512, 400)),
-        (Extent(2048, 1536), 0.5, Extent(728, 544), Extent(1024, 768)),
+        (Extent(2048, 1536), 0.5, Extent(736, 544), Extent(1024, 768)),
         (Extent(1024, 1024), 0.4, Extent(512, 512), Extent(512, 512)),
         (Extent(512, 768), 0.5, Extent(512, 768), Extent(512, 768)),
-        (Extent(512, 512), 2.0, Extent(632, 632), Extent(1024, 1024)),
-        (Extent(512, 512), 1.1, Extent(568, 568), Extent(568, 568)),
+        (Extent(512, 512), 2.0, Extent(640, 640), Extent(1024, 1024)),
+        (Extent(512, 512), 1.1, Extent(576, 576), Extent(576, 576)),
     ],
     ids=["1.0", "0.5", "0.5_large", "0.4", "0.5_tall", "2.0", "1.1"],
 )
@@ -296,13 +296,13 @@ def test_prepare_resolution_multiplier_inputs(multiplier):
 
 @pytest.mark.parametrize(
     "multiplier,expected",
-    [(0.5, Extent(1024, 1024)), (2, Extent(1000, 1000)), (0.25, Extent(512, 512))],
+    [(0.5, Extent(1024, 1024)), (2, Extent(1008, 1008)), (0.25, Extent(512, 512))],
 )
 def test_prepare_resolution_multiplier_max(multiplier, expected):
     perf_settings = PerformanceSettings(resolution_multiplier=multiplier, max_pixel_count=1)
     input = Extent(2048, 2048)
     r, _ = resolution.prepare_extent(input, Arch.sd15, dummy_style, perf_settings)
-    assert r.extent.initial.width <= 632 and r.extent.desired == expected
+    assert r.extent.initial.width <= 640 and r.extent.desired == expected
 
 
 tile_layouts = {

tests/test_workflow.py

@@ -503,7 +503,7 @@ def test_refine(qtapp, client, setup):
 
     sdver, extent, strength = {
         "sd15": (Arch.sd15, Extent(768, 508), 0.5),
-        "sdxl": (Arch.sdxl, Extent(1111, 741), 0.65),
+        "sdxl": (Arch.sdxl, Extent(1111, 741), 0.5),
         "flux": (Arch.flux, Extent(1111, 741), 0.65),
         "flux_k": (Arch.flux_k, Extent(1111, 741), 1.0),
         "flux2": (Arch.flux2_4b, Extent(1111, 741), 1.0),