autoforge 1.8.2__tar.gz → 1.8.4__tar.gz

{autoforge-1.8.2 → autoforge-1.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AutoForge
-Version: 1.8.2
+Version: 1.8.4
 Summary: AutoForge is a Python tool for generating 3D printed layered models from an input image.
 Author-email: Hendric Voss <hvoss@techfak.uni-bielefeld.de>
 License: CC BY-NC-SA 4.0
@@ -133,7 +133,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--perform_pruning`  Perform pruning after optimization (default: True).  
   **Note:** This is highly recommended even if you don't have a color/color swap limit, as it actually increases the quality of the output.
 - `--fast_pruning`  Perform pruning in chunks. 10-15x speedup compared to accurate method (default: False).
-- `--fast_pruning_percent` Size of fast pruning chunks in percent (default: 0.2) (20%).
+- `--fast_pruning_percent` Size of fast pruning chunks in percent (default: 0.5) (50%).
 - `--pruning_max_colors` Max number of colors allowed after pruning (default: 100).
 - `--pruning_max_swaps` Max number of swaps allowed after pruning (default: 100).
 - `--pruning_max_layer` Max number of layers allowed after pruning (default: 75).
@@ -145,7 +145,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--num_init_rounds` Number of rounds to choose the starting height map from (default: 128).
 - `--num_init_cluster_layers` Number of layers to cluster the image into (default: -1).
 - `--disable_visualization_for_gradio` Simple switch to disable the matplotlib render window for gradio rendering (default: 0).
-
+- `--best_of` Run the entire program multiple times and output the best result (default: 1)
 
 ## Outputs
 

{autoforge-1.8.2 → autoforge-1.8.4}/README.md

@@ -107,7 +107,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--perform_pruning`  Perform pruning after optimization (default: True).  
   **Note:** This is highly recommended even if you don't have a color/color swap limit, as it actually increases the quality of the output.
 - `--fast_pruning`  Perform pruning in chunks. 10-15x speedup compared to accurate method (default: False).
-- `--fast_pruning_percent` Size of fast pruning chunks in percent (default: 0.2) (20%).
+- `--fast_pruning_percent` Size of fast pruning chunks in percent (default: 0.5) (50%).
 - `--pruning_max_colors` Max number of colors allowed after pruning (default: 100).
 - `--pruning_max_swaps` Max number of swaps allowed after pruning (default: 100).
 - `--pruning_max_layer` Max number of layers allowed after pruning (default: 75).
@@ -119,7 +119,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--num_init_rounds` Number of rounds to choose the starting height map from (default: 128).
 - `--num_init_cluster_layers` Number of layers to cluster the image into (default: -1).
 - `--disable_visualization_for_gradio` Simple switch to disable the matplotlib render window for gradio rendering (default: 0).
-
+- `--best_of` Run the entire program multiple times and output the best result (default: 1)
 
 ## Outputs
 

{autoforge-1.8.2 → autoforge-1.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "AutoForge"
-version="1.8.2"
+version="1.8.4"
 description = "AutoForge is a Python tool for generating 3D printed layered models from an input image."
 authors = [{ name = "Hendric Voss", email = "hvoss@techfak.uni-bielefeld.de" }]
 readme = "README.md"

{autoforge-1.8.2 → autoforge-1.8.4}/src/AutoForge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AutoForge
-Version: 1.8.2
+Version: 1.8.4
 Summary: AutoForge is a Python tool for generating 3D printed layered models from an input image.
 Author-email: Hendric Voss <hvoss@techfak.uni-bielefeld.de>
 License: CC BY-NC-SA 4.0
@@ -133,7 +133,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--perform_pruning`  Perform pruning after optimization (default: True).  
   **Note:** This is highly recommended even if you don't have a color/color swap limit, as it actually increases the quality of the output.
 - `--fast_pruning`  Perform pruning in chunks. 10-15x speedup compared to accurate method (default: False).
-- `--fast_pruning_percent` Size of fast pruning chunks in percent (default: 0.2) (20%).
+- `--fast_pruning_percent` Size of fast pruning chunks in percent (default: 0.5) (50%).
 - `--pruning_max_colors` Max number of colors allowed after pruning (default: 100).
 - `--pruning_max_swaps` Max number of swaps allowed after pruning (default: 100).
 - `--pruning_max_layer` Max number of layers allowed after pruning (default: 75).
@@ -145,7 +145,7 @@ autoforge --input_image path/to/input_image.jpg --csv_file path/to/materials.csv
 - `--num_init_rounds` Number of rounds to choose the starting height map from (default: 128).
 - `--num_init_cluster_layers` Number of layers to cluster the image into (default: -1).
 - `--disable_visualization_for_gradio` Simple switch to disable the matplotlib render window for gradio rendering (default: 0).
-
+- `--best_of` Run the entire program multiple times and output the best result (default: 1)
 
 ## Outputs
 

{autoforge-1.8.2 → autoforge-1.8.4}/src/autoforge/Helper/Heightmaps/ChristofidesHeightMap.py

@@ -440,7 +440,7 @@ def init_height_map(
     background_tuple,
     eps=1e-6,
     random_seed=None,
-    lab_weights=(2.0, 1.0, 1.0),
+    lab_weights=(1.0, 1.0, 1.0),
     init_method="quantize_maxcoverage",
     cluster_layers=None,
     lab_space=True,
@@ -461,7 +461,7 @@ def init_height_map(
     import random
 
     if cluster_layers is None:
-        cluster_layers = max_layers
+        cluster_layers = max_layers // 2
 
     if random_seed is not None:
         np.random.seed(random_seed)
@@ -482,7 +482,7 @@ def init_height_map(
         target_lab_reshaped,
         H,
         W,
-        overcluster_k=150,
+        overcluster_k=500,
         final_k=cluster_layers,
         beta_distinct=4.0,
         random_state=random_seed,
@@ -578,7 +578,7 @@ def init_height_map(
         ordering_metric,
         cluster_layers,
         sil_score,
-        new_labels * cluster_layers,
+        labels.reshape(H, W),
     )
 
 

{autoforge-1.8.2 → autoforge-1.8.4}/src/autoforge/Helper/OptimizerHelper.py

@@ -1,3 +1,5 @@
+from contextlib import contextmanager
+
 import torch
 import torch.nn.functional as F
 
@@ -95,6 +97,41 @@ def deterministic_gumbel_softmax(
     return y
 
 
+@torch.jit.script
+def bleed_layer_effect(mask: torch.Tensor, strength: float = 0.1) -> torch.Tensor:
+    """
+    Applies a simple 2D 3x3 average blur to simulate edge bleeding.
+
+    Args:
+        mask (torch.Tensor): [H,W] or [L,H,W] tensor of masks.
+        strength (float): Amount of the bleed to spread to neighbors.
+
+    Returns:
+        torch.Tensor: Mask with neighboring bleed added.
+    """
+    if mask.dim() == 2:
+        mask = mask.unsqueeze(0)  # [1,H,W]
+    L, H, W = mask.shape
+
+    # 3x3 average kernel
+    kernel = (
+        torch.tensor(
+            [[1, 1, 1], [1, 0, 1], [1, 1, 1]], dtype=mask.dtype, device=mask.device
+        )
+        / 8.0
+    )  # 8 neighbors
+
+    kernel = kernel.view(1, 1, 3, 3)
+
+    # Apply conv2d to each layer independently
+    blurred = F.conv2d(mask.unsqueeze(1), kernel, padding=1, groups=1).squeeze(
+        1
+    )  # [L,H,W]
+
+    # Combine original mask with bleed from neighbors
+    return mask + strength * blurred
+
+
 @torch.jit.script
 def composite_image_cont(
     pixel_height_logits: torch.Tensor,  # [H,W]
@@ -131,7 +168,8 @@ def composite_image_cont(
     )  # [L,H,W]
 
     # 4. thickness and opacity
-    eff_thick = p_print * h  # [L,H,W]
+    p_print_bleed = bleed_layer_effect(p_print, strength=0.1)  # [L,H,W]
+    eff_thick = torch.clamp(p_print_bleed, 0.0, 1.0) * h
     thick_ratio = eff_thick / layer_TDs.view(-1, 1, 1)  # [L,H,W]
 
     o, A, k, b = -1.2416557e-02, 9.6407950e-01, 3.4103447e01, -4.1554203e00
@@ -252,7 +290,8 @@ def composite_image_disc(
     )  # [L,H,W]
 
     # 4. Thickness, opacity and the rest exactly as in the continuous version.
-    eff_thick: torch.Tensor = p_print * h  # [L,H,W]
+    p_print_bleed = bleed_layer_effect(p_print, strength=0.1)  # [L,H,W]
+    eff_thick = torch.clamp(p_print_bleed, 0.0, 1.0) * h
     thick_ratio: torch.Tensor = eff_thick / layer_TDs.view(-1, 1, 1)  # [L,H,W]
 
     o, A, k, b = -1.2416557e-02, 9.6407950e-01, 3.4103447e01, -4.1554203e00
@@ -277,3 +316,63 @@ def composite_image_disc(
     comp = comp + rem_after.unsqueeze(-1) * background  # [H,W,3]
 
     return comp * 255.0
+
+
+def _gpu_capability(device):
+    major, minor = torch.cuda.get_device_capability(device)
+    return major * 10 + minor  # 80, 61, …
+
+
+def _has_fp16(device):
+    return _gpu_capability(device) >= 53  # CC 5.3 or newer
+
+
+class PrecisionManager:
+    """
+    Usage
+    -----
+    prec = PrecisionManager(device)
+    with prec.autocast():
+        loss = model(...)
+    prec.backward_and_step(loss, optimizer)
+    """
+
+    def __init__(self, device):
+        self.device = device
+        self.scaler = None
+        self.autocast_dtype = None
+        self.enabled = False
+
+        if device.type == "cuda":
+            if torch.cuda.is_bf16_supported():
+                print("Using bfloat16 autocast for CUDA.")
+                self.autocast_dtype = torch.bfloat16  # fastest if available
+                self.scaler = torch.cuda.amp.GradScaler()
+                self.enabled = True
+            elif _has_fp16(device):
+                print("Using float16 autocast for CUDA.")
+                self.autocast_dtype = torch.float16
+                self.scaler = torch.cuda.amp.GradScaler()
+                self.enabled = True
+            else:
+                print("Using float32 autocast for CUDA.")
+                # TF32 fallback for very old GPUs
+                torch.backends.cuda.matmul.allow_tf32 = True
+                torch.backends.cudnn.allow_tf32 = True
+
+    @contextmanager
+    def autocast(self):
+        if self.enabled:
+            with torch.cuda.amp.autocast(dtype=self.autocast_dtype):
+                yield
+        else:
+            yield  # FP32 path
+
+    def backward_and_step(self, loss, optimizer):
+        if self.scaler is not None:  # FP16 path
+            self.scaler.scale(loss).backward()
+            self.scaler.step(optimizer)
+            self.scaler.update()
+        else:
+            loss.backward()
+            optimizer.step()

{autoforge-1.8.2 → autoforge-1.8.4}/src/autoforge/Helper/PruningHelper.py

@@ -414,24 +414,7 @@ def prune_redundant_layers(
     optimizer.max_layers = current_max_layers  # keep optimiser in sync
 
     # Baseline loss with current best parameters
-    with _gpu_lock, torch.no_grad():
-        eff_logits = optimizer._apply_height_offset(
-            optimizer.best_params["pixel_height_logits"],
-            optimizer.best_params["height_offsets"],
-        )
-        ref_comp = composite_image_disc(
-            eff_logits,
-            optimizer.best_params["global_logits"],
-            optimizer.vis_tau,
-            optimizer.vis_tau,
-            optimizer.h,
-            current_max_layers,
-            optimizer.material_colors,
-            optimizer.material_TDs,
-            optimizer.background,
-            rng_seed=optimizer.best_seed,
-        )
-        best_loss = compute_loss(ref_comp, optimizer.target).item()
+    best_loss = get_initial_loss(current_max_layers, optimizer)
 
     tbar = tqdm(
         desc=f"Layer pruning | Loss {best_loss:.4f}",
@@ -570,6 +553,28 @@ def prune_redundant_layers(
     return optimizer.best_params, best_loss, current_max_layers
 
 
+def get_initial_loss(current_max_layers, optimizer):
+    with _gpu_lock, torch.no_grad():
+        eff_logits = optimizer._apply_height_offset(
+            optimizer.best_params["pixel_height_logits"],
+            optimizer.best_params["height_offsets"],
+        )
+        ref_comp = composite_image_disc(
+            eff_logits,
+            optimizer.best_params["global_logits"],
+            optimizer.vis_tau,
+            optimizer.vis_tau,
+            optimizer.h,
+            current_max_layers,
+            optimizer.material_colors,
+            optimizer.material_TDs,
+            optimizer.background,
+            rng_seed=optimizer.best_seed,
+        )
+        best_loss = compute_loss(ref_comp, optimizer.target).item()
+    return best_loss
+
+
 def remove_outlier_pixels(
     height_logits: torch.Tensor, threshold: float
 ) -> torch.Tensor:
@@ -771,3 +776,91 @@ def smooth_coplanar_faces(
     smoothed_height_logits = coplanar_sum / count.clamp(min=1)
 
     return smoothed_height_logits
+
+
+def optimise_swap_positions(
+    optimizer: FilamentOptimizer,
+    n_jobs: int | None = -1,
+    *,
+    allowed_loss_increase_percent: float = 0.0,
+) -> torch.Tensor:
+    """
+    Exhaustively move each swap boundary to every admissible layer and keep the
+    best configuration. Uses a progress bar to display changes.
+
+    Returns
+    -------
+    torch.Tensor
+        The discrete global assignment with optimised swap positions.
+    """
+
+    num_materials = optimizer.material_colors.shape[0]
+
+    def disc_loss(dg_test: torch.Tensor) -> float:
+        logits_for_disc = disc_to_logits(dg_test, num_materials, big_pos=1e5)
+        with _gpu_lock, torch.no_grad():
+            out = optimizer.get_best_discretized_image(
+                custom_global_logits=logits_for_disc
+            )
+            return compute_loss(comp=out, target=optimizer.target).item()
+
+    best_dg, _ = optimizer.get_discretized_solution(best=True)
+    best_loss = disc_loss(best_dg)
+
+    outer_tbar = tqdm(desc="Optimising swap positions", total=100, leave=False)
+    improved = True
+    while improved:
+        improved = False
+        outer_tbar.update(1)
+
+        bands = find_color_bands(best_dg)
+        num_swaps = len(bands) - 1
+        if num_swaps == 0:
+            break
+
+        for swap_idx in range(num_swaps):
+            band_a = bands[swap_idx]
+            band_b = bands[swap_idx + 1]
+
+            lower_limit = bands[swap_idx - 1][1] + 1 if swap_idx > 0 else 0
+            upper_limit = (
+                bands[swap_idx + 2][0] - 1
+                if swap_idx + 2 < len(bands)
+                else best_dg.size(0) - 1
+            )
+
+            if lower_limit >= upper_limit:
+                continue
+
+            def candidate_loss(new_boundary: int):
+                if new_boundary == band_a[1]:
+                    return float("inf"), None, None
+                dg_new = best_dg.clone()
+                dg_new[lower_limit : new_boundary + 1] = band_a[2]
+                dg_new[new_boundary + 1 : upper_limit + 1] = band_b[2]
+                return disc_loss(dg_new), dg_new, new_boundary
+
+            results = Parallel(n_jobs=n_jobs, backend="threading", prefer="threads")(
+                delayed(candidate_loss)(b) for b in range(lower_limit, upper_limit + 1)
+            )
+
+            cand_loss, cand_dg, new_pos = min(results, key=lambda x: x[0])
+
+            if cand_loss < best_loss * (1 + allowed_loss_increase_percent):
+                old_pos = band_a[1]
+                best_dg = cand_dg
+                best_loss = cand_loss
+                optimizer.best_params["global_logits"] = disc_to_logits(
+                    best_dg, num_materials=num_materials, big_pos=1e5
+                )
+                outer_tbar.set_description(
+                    f"Swap {swap_idx} moved {old_pos}->{new_pos} | Loss {best_loss:.4f}"
+                )
+                print(
+                    f"Swap {swap_idx} moved {old_pos}->{new_pos} | Loss {best_loss:.4f}"
+                )
+                improved = True
+                break
+
+    outer_tbar.close()
+    return best_dg

autoforge-1.8.4/src/autoforge/Init_comparer/auto_forge_init_check.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+"""
+Grid-runner for autoforge.py
+
+Usage example (inline defaults):
+    python run_autoforge_grid.py
+"""
+
+import json
+import subprocess
+import sys
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from itertools import product
+from pathlib import Path
+from time import strftime
+
+from tqdm import tqdm
+
+# ---------- editable section ---------- #
+# Any CLI flag accepted by autoforge.py can be placed here.
+DEFAULT_ARGS: dict[str, object] = {
+    "--csv_file": "../../../bambulab.csv",
+    "--iterations": 6000,
+    "--num_init_rounds": 8,
+    "--stl_output_size": 50,
+    "--disable_visualization_for_gradio": 1,
+    "--warmup_fraction": 1.0,
+    "--fast_pruning_percent": 0.05,
+    "--learning_rate_warmup_fraction": 0.01,
+}
+
+SWEEP_PARAM = "--learning_rate"  # param to overwrite per run
+SWEEP_VALUES = [
+    0.01,
+    0.02,
+    0.03,
+]  # ,0.04,0.05,0.06,0.07,0.08,0.09,0.1]  # values to sweep over
+
+IMAGES_DIR = Path("/home/scsadmin/AutoForge/images/test_images")
+BASE_OUTPUT_DIR = Path("output_grid")  # all run folders are created inside here
+MAX_WORKERS = 16  # parallel jobs
+# ---------- end editable section ------ #
+
+
+def make_cmd(image_path: Path, param_value, run_dir: Path, idx: int) -> list[str]:
+    """Assemble the command line for one run."""
+    cmd: list[str] = [
+        sys.executable,
+        "../auto_forge.py",
+        "--input_image",
+        str(image_path),
+        "--output_folder",
+        str(run_dir),
+        "--random_seed",
+        str(idx + 1),
+    ]
+
+    # default args
+    for flag, val in DEFAULT_ARGS.items():
+        if isinstance(val, bool):
+            if val:  # store_true flag
+                cmd.append(flag)
+        else:
+            cmd.extend([flag, str(val)])
+
+    # swept parameter
+    cmd.extend([SWEEP_PARAM, str(param_value)])
+    return cmd
+
+
+def run_single(image_path: Path, param_value, idx) -> dict:
+    """Worker: launch subprocess, parse loss, return result dict."""
+    run_dir = BASE_OUTPUT_DIR / (
+        f"{image_path.stem}_{idx}_{SWEEP_PARAM.lstrip('-')}={param_value}"
+    )
+    run_dir.mkdir(parents=True, exist_ok=True)
+
+    cmd = make_cmd(image_path, param_value, run_dir, idx)
+
+    proc = subprocess.run(cmd, capture_output=True, text=True)
+    # print output
+    if proc.returncode != 0:
+        print(f"Running: {' '.join(cmd)}")
+        print(f"Return code: {proc.returncode}")
+        print(f"Stdout: {proc.stdout.strip()}")
+        print(f"Stderr: {proc.stderr.strip()}")
+
+    loss_file = run_dir / "final_loss.txt"
+    loss = None
+    if loss_file.exists():
+        try:
+            loss = float(loss_file.read_text().strip())
+        except ValueError:
+            pass
+
+    return {
+        "image": str(image_path),
+        "param_value": param_value,
+        "loss": loss,
+        "output_folder": str(run_dir),
+        "returncode": proc.returncode,
+        "stdout": proc.stdout,
+        "stderr": proc.stderr,
+    }
+
+
+def main():
+    values = SWEEP_VALUES
+
+    images = [
+        p for p in IMAGES_DIR.iterdir() if p.suffix.lower() in {".png", ".jpg", ".jpeg"}
+    ]
+
+    BASE_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    ts = strftime("%Y%m%d_%H%M%S")
+    # run grid
+    results = []
+    with ProcessPoolExecutor(max_workers=MAX_WORKERS) as pool:
+        futures = {
+            pool.submit(run_single, img, val, idx): (img, val)
+            for idx in range(1)
+            for img, val in product(images, values)
+        }
+        for fut in tqdm(as_completed(futures), total=len(futures), desc="Running grid"):
+            res = fut.result()
+            results.append(res)
+            print(
+                f"✓ finished {Path(res['image']).name} "
+                f"{SWEEP_PARAM}={res['param_value']} loss={res['loss']}"
+            )
+
+            # write summary
+
+            out_path = BASE_OUTPUT_DIR / f"out_dict_{ts}.json"
+            with open(out_path, "w") as fp:
+                json.dump(results, fp, indent=2)
+    print(f"Results saved to {out_path}")
+
+
+if __name__ == "__main__":
+    main()

autoforge-1.8.4/src/autoforge/Init_comparer/plot_results.py

@@ -0,0 +1,116 @@
+import json
+import os
+import traceback
+
+import numpy as np
+import plotly.graph_objects as go
+from scipy.optimize import curve_fit
+
+json_file = [f for f in os.listdir("output_grid") if f.endswith(".json")][0]
+# Load the JSON file with arbitrary keys
+with open(f"output_grid/{json_file}", "r") as f:
+    data = json.load(f)
+
+# Calculate means, standard deviations, and store the arrays for each condition.
+# We store as a tuple: (key, mean, std, data array)
+stats = {}
+for run in data:
+    param_value = run["param_value"]
+    loss = run["loss"]
+    stats.setdefault(param_value, []).append(loss)
+
+# Sort the list of tuples based on the mean (ascending order)
+# stats.sort(key=lambda x: x[1])
+
+# Extract sorted lists of keys, means, stds, and store the sorted arrays in a dictionary
+sorted_keys = sorted(list(stats.keys()))
+means = [np.mean(stats[key]) for key in sorted_keys]
+stds = [np.std(stats[key]) for key in sorted_keys]
+n_keys = len(sorted_keys)
+
+# print number of samples for every key:
+for key in sorted_keys:
+    print(f"{key}: {len(stats[key])} samples")
+
+# sprt all by lowest mean value
+# sorted_indices = np.argsort(means)
+# sorted_keys = [sorted_keys[i] for i in sorted_indices]
+# means = [means[i] for i in sorted_indices]
+# stds = [stds[i] for i in sorted_indices]
+
+# Create x-positions for the bars (one per key)
+x_positions = list(range(n_keys))
+
+# Create a Plotly bar chart with error bars
+fig = go.Figure()
+for i, key in enumerate(sorted_keys):
+    fig.add_trace(
+        go.Bar(
+            name=key,
+            x=[x_positions[i]],
+            y=[means[i]],
+            error_y=dict(type="data", array=[stds[i]], visible=True),
+        )
+    )
+
+
+# Define an exponential decay function
+def exp_decay(x, a, b, c):
+    return a * np.exp(-b * x) + c
+
+
+# Convert x_positions and means to numpy arrays for curve fitting
+x_data = np.array(x_positions)
+y_data = np.array(means)
+try:
+    # Fit the curve
+    popt, _ = curve_fit(exp_decay, x_data, y_data, p0=(1, 0.1, 0))  # initial guesses
+
+    # Generate smooth x values for the fitted curve
+    x_fit = np.linspace(min(x_data), max(x_data), 500)
+    y_fit = exp_decay(x_fit, *popt)
+
+    # Add the fitted curve to the figure
+    fig.add_trace(
+        go.Scatter(
+            x=x_fit,
+            y=y_fit,
+            mode="lines",
+            name="Exponential Fit",
+            line=dict(dash="dash", width=3),
+        )
+    )
+except Exception:
+    traceback.print_exc()
+
+threshold = 0.05  # 1% improvement
+for i in range(1, len(means)):
+    rel_change = (means[i - 1] - means[i]) / means[i - 1]
+    print(
+        f"{sorted_keys[i - 1]} -> {sorted_keys[i]}: relative change = {rel_change:.4f}"
+    )
+    if rel_change < threshold:
+        print(
+            f"Diminishing returns start at x = {sorted_keys[i]} (relative change = {rel_change:.4f})"
+        )
+
+fig.update_layout(
+    title="Comparison of Conditions with Mean ± STD (Sorted by Mean)",
+    xaxis=dict(
+        tickmode="array",
+        tickvals=x_positions,
+        ticktext=sorted_keys,
+        tickangle=45,  # Rotate labels for better readability
+    ),
+    yaxis_title="Value",
+    barmode="group",
+)
+
+
+fig.update_layout(
+    autosize=False,
+    width=1920,
+    height=800,
+)
+# save image
+fig.write_image("out.png")