Remove obsolete duplicate Claim 5 page

pages/claim-5-modular-style-transfer/page.md

@@ -1,675 +0,0 @@
-# claim-5-modular-style-transfer
-
-
----
-<!-- trackio-cell
-{"type": "code", "id": "cell_bfc1be2c467e", "created_at": "2026-07-16T07:28:04+00:00", "title": "Direct core-matrix interpolation: explicit A_alpha blend on the trained four-style checkpoint", "command": ["/home/ubuntu/samuel/repro/.venv-torch/bin/python", "claim5_direct_core_blend.py", "--device", "cuda", "--output-dir", "outputs/claim5_direct_core_blend_logged"], "exit_code": 0, "duration_s": 60.134}
--->
-````bash
-$ /home/ubuntu/samuel/repro/.venv-torch/bin/python claim5_direct_core_blend.py --device cuda --output-dir outputs/claim5_direct_core_blend_logged
-````
-
-exit 0 · 60.1s
-
-
-````python title=claim5_direct_core_blend.py
-#!/usr/bin/env python3
-"""Direct matrix interpolation audit for the Linearizer style model.
-
-The released ``style_intrepolations.py`` interpolates the scalar conditioning
-index passed to a nonlinear hypernetwork.  This script tests the stronger
-matrix-algebra claim explicitly:
-
-    A_alpha = (1 - alpha) A_style_1 + alpha A_style_2
-    y_alpha = g_y^{-1}(A_alpha g_x(x)).
-
-``g_x(x)`` is computed exactly once, ``g_x`` and ``g_y`` remain fixed, and the
-direct core chord is compared with the repository's conditioned-index path.
-The output JSON contains the actual 3x4x4 endpoint/direct/conditioned kernels,
-per-alpha comparisons, endpoint checks, and path-smoothness diagnostics.
-"""
-
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import math
-import os
-import platform
-import random
-import sys
-import time
-from pathlib import Path
-from typing import Any, Iterable
-
-os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8")
-
-import numpy as np
-import torch
-from PIL import Image
-from torch import Tensor
-from torchvision.transforms import ToTensor
-
-WORKSPACE = Path(__file__).resolve().parent
-LINEARIZER_ROOT = WORKSPACE / "Linearizer"
-STYLE_ROOT = LINEARIZER_ROOT / "style_transfer"
-
-# The full-object checkpoint refers to both ``style_transfer.*`` and modules
-# imported from the Linearizer repository root.  Register both roots before
-# torch.load unpickles it.
-for import_root in (str(STYLE_ROOT), str(LINEARIZER_ROOT)):
-    if import_root not in sys.path:
-        sys.path.insert(0, import_root)
-
-from style_transfer.modules.linear_network import batch_depthwise_conv2d  # noqa: E402
-
-STYLE_TO_INDEX = {
-    "mosaic": 0,
-    "candy": 1,
-    "rain_princess": 2,
-    "udnie": 3,
-}
-DEFAULT_PAIRS = ("candy:rain_princess", "mosaic:udnie")
-DEFAULT_ALPHAS = tuple(index / 8 for index in range(9))
-
-
-def parse_args(argv: Iterable[str] | None = None) -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Compare direct Linearizer core blending with conditioned-index interpolation."
-    )
-    parser.add_argument(
-        "--model-path",
-        type=Path,
-        default=STYLE_ROOT / "outputs/07_16_12_26_15/model.pth",
-    )
-    parser.add_argument(
-        "--image-path",
-        type=Path,
-        default=STYLE_ROOT / "david_256x256/original.png",
-    )
-    parser.add_argument(
-        "--output-dir",
-        type=Path,
-        default=WORKSPACE / "outputs/claim5_direct_core_blend",
-    )
-    parser.add_argument(
-        "--pairs",
-        nargs="+",
-        default=list(DEFAULT_PAIRS),
-        metavar="STYLE1:STYLE2",
-    )
-    parser.add_argument(
-        "--alphas",
-        nargs="+",
-        type=float,
-        default=list(DEFAULT_ALPHAS),
-        help="ordered blend coefficients; must include 0 and 1",
-    )
-    parser.add_argument("--device", default="auto", help="auto, cpu, cuda, or cuda:N")
-    parser.add_argument("--seed", type=int, default=25191)
-    parser.add_argument("--dpi", type=int, default=170)
-    args = parser.parse_args(argv)
-
-    parsed_pairs: list[tuple[str, str]] = []
-    for pair in args.pairs:
-        pieces = pair.split(":")
-        if len(pieces) != 2 or any(piece not in STYLE_TO_INDEX for piece in pieces):
-            parser.error(
-                f"invalid pair {pair!r}; styles are {', '.join(STYLE_TO_INDEX)}"
-            )
-        if pieces[0] == pieces[1]:
-            parser.error(f"style pair must contain two distinct endpoints: {pair!r}")
-        parsed_pairs.append((pieces[0], pieces[1]))
-    args.pairs = parsed_pairs
-
-    if len(args.alphas) < 3:
-        parser.error("provide at least three alpha values")
-    if any(alpha < 0.0 or alpha > 1.0 for alpha in args.alphas):
-        parser.error("all alpha values must lie in [0,1]")
-    if args.alphas != sorted(args.alphas) or len(set(args.alphas)) != len(args.alphas):
-        parser.error("alpha values must be unique and increasing")
-    if not math.isclose(args.alphas[0], 0.0) or not math.isclose(args.alphas[-1], 1.0):
-        parser.error("alpha values must begin at 0 and end at 1")
-    if args.dpi <= 0:
-        parser.error("--dpi must be positive")
-    return args
-
-
-def choose_device(requested: str) -> torch.device:
-    if requested == "auto":
-        return torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    device = torch.device(requested)
-    if device.type == "cuda" and not torch.cuda.is_available():
-        raise RuntimeError("CUDA was requested but is unavailable")
-    return device
-
-
-def seed_everything(seed: int) -> None:
-    random.seed(seed)
-    np.random.seed(seed)
-    torch.manual_seed(seed)
-    if torch.cuda.is_available():
-        torch.cuda.manual_seed_all(seed)
-    torch.use_deterministic_algorithms(True, warn_only=True)
-    if hasattr(torch.backends, "cudnn"):
-        torch.backends.cudnn.benchmark = False
-        torch.backends.cudnn.deterministic = True
-    if hasattr(torch.backends, "cuda") and hasattr(torch.backends.cuda, "matmul"):
-        torch.backends.cuda.matmul.allow_tf32 = False
-
-
-def file_sha256(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as handle:
-        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def tensor_sha256(tensor: Tensor) -> str:
-    values = tensor.detach().cpu().contiguous().numpy()
-    return hashlib.sha256(values.tobytes()).hexdigest()
-
-
-def load_rgb(path: Path) -> Tensor:
-    with Image.open(path) as image:
-        return ToTensor()(image.convert("RGB"))
-
-
-def error_metrics(first: Tensor, second: Tensor) -> dict[str, float]:
-    difference = (first - second).double()
-    mse = float(difference.square().mean())
-    return {
-        "mse": mse,
-        "rms": math.sqrt(mse),
-        "mean_abs": float(difference.abs().mean()),
-        "max_abs": float(difference.abs().max()),
-        "psnr_db_assuming_unit_range": -10.0 * math.log10(max(mse, 1e-15)),
-    }
-
-
-def output_summary(output: Tensor) -> dict[str, float | str]:
-    return {
-        "min": float(output.min()),
-        "max": float(output.max()),
-        "mean": float(output.double().mean()),
-        "std": float(output.double().std()),
-        "sha256_float32": tensor_sha256(output.float()),
-        "sha256_display_clipped_float32": tensor_sha256(output.clamp(0, 1).float()),
-    }
-
-
-def path_smoothness(images: list[Tensor], alphas: list[float]) -> dict[str, Any]:
-    if len(images) != len(alphas):
-        raise ValueError("images and alpha schedules must have the same length")
-    successive_rms = [
-        error_metrics(images[index + 1], images[index])["rms"]
-        for index in range(len(images) - 1)
-    ]
-    successive_per_alpha = [
-        step / (alphas[index + 1] - alphas[index])
-        for index, step in enumerate(successive_rms)
-    ]
-    second_difference_rms = []
-    if len(images) >= 3:
-        # This diagnostic is directly comparable across the default uniform
-        # schedule.  For a nonuniform custom schedule, also report the
-        # first-derivative changes below.
-        for index in range(1, len(images) - 1):
-            second = images[index + 1] - 2.0 * images[index] + images[index - 1]
-            second_difference_rms.append(
-                float(torch.sqrt(second.double().square().mean()))
-            )
-    velocity_changes = [
-        abs(successive_per_alpha[index + 1] - successive_per_alpha[index])
-        for index in range(len(successive_per_alpha) - 1)
-    ]
-    chord_rms = error_metrics(images[-1], images[0])["rms"]
-    path_length = float(sum(successive_rms))
-    mean_step = float(np.mean(successive_rms))
-    std_step = float(np.std(successive_rms))
-    return {
-        "successive_image_rms": successive_rms,
-        "successive_rms_per_alpha": successive_per_alpha,
-        "second_difference_rms": second_difference_rms,
-        "mean_abs_velocity_change": (
-            float(np.mean(velocity_changes)) if velocity_changes else 0.0
-        ),
-        "max_abs_velocity_change": max(velocity_changes, default=0.0),
-        "mean_step_rms": mean_step,
-        "step_rms_coefficient_of_variation": std_step / mean_step if mean_step else 0.0,
-        "endpoint_chord_rms": chord_rms,
-        "path_length_sum_rms": path_length,
-        "path_to_chord_ratio": path_length / chord_rms if chord_rms else 1.0,
-    }
-
-
-def core_path_smoothness(cores: list[Tensor]) -> dict[str, Any]:
-    successive = [
-        error_metrics(cores[index + 1], cores[index])["rms"]
-        for index in range(len(cores) - 1)
-    ]
-    second_differences = [
-        float(
-            torch.sqrt(
-                (cores[index + 1] - 2.0 * cores[index] + cores[index - 1])
-                .double()
-                .square()
-                .mean()
-            )
-        )
-        for index in range(1, len(cores) - 1)
-    ]
-    mean_step = float(np.mean(successive))
-    return {
-        "successive_core_rms": successive,
-        "max_second_difference_rms": max(second_differences, default=0.0),
-        "mean_second_difference_rms": (
-            float(np.mean(second_differences)) if second_differences else 0.0
-        ),
-        "step_rms_coefficient_of_variation": (
-            float(np.std(successive)) / mean_step if mean_step else 0.0
-        ),
-    }
-
-
-def endpoint_target_metrics(
-    output: Tensor, reference_path: Path
-) -> dict[str, Any] | None:
-    if not reference_path.exists():
-        return None
-    reference = load_rgb(reference_path).unsqueeze(0)
-    if output.shape != reference.shape:
-        raise ValueError(
-            f"reference {reference_path} has shape {tuple(reference.shape)}, "
-            f"expected {tuple(output.shape)}"
-        )
-    return {
-        "reference_path": str(reference_path.resolve()),
-        "reference_sha256": file_sha256(reference_path),
-        "raw_output_vs_reference": error_metrics(output.cpu(), reference),
-        "clipped_output_vs_reference": error_metrics(
-            output.cpu().clamp(0, 1), reference
-        ),
-    }
-
-
-@torch.inference_mode()
-def evaluate_pair(
-    linearizer: torch.nn.Module,
-    encoded_content: Tensor,
-    style1: str,
-    style2: str,
-    alphas: list[float],
-    device: torch.device,
-    reference_dir: Path,
-) -> tuple[dict[str, Any], list[Tensor], list[Tensor], list[Tensor]]:
-    index1 = STYLE_TO_INDEX[style1]
-    index2 = STYLE_TO_INDEX[style2]
-    core_module = linearizer.linear_network
-    if not hasattr(core_module, "get_matrix"):
-        raise TypeError("the loaded core module does not expose get_matrix(t)")
-
-    t1 = torch.tensor([float(index1)], device=device)
-    t2 = torch.tensor([float(index2)], device=device)
-    core1 = core_module.get_matrix(t1)
-    core2 = core_module.get_matrix(t2)
-    if core1.shape != core2.shape or core1.ndim != 4:
-        raise ValueError(
-            f"unexpected endpoint core shapes: {tuple(core1.shape)} and {tuple(core2.shape)}"
-        )
-
-    direct_cores: list[Tensor] = []
-    conditioned_cores: list[Tensor] = []
-    direct_images: list[Tensor] = []
-    conditioned_images: list[Tensor] = []
-    abs_difference_images: list[Tensor] = []
-    alpha_rows: list[dict[str, Any]] = []
-
-    endpoint_latent1 = batch_depthwise_conv2d(encoded_content, core1)
-    endpoint_latent2 = batch_depthwise_conv2d(encoded_content, core2)
-
-    for alpha in alphas:
-        direct_core = (1.0 - alpha) * core1 + alpha * core2
-        conditioned_t = (1.0 - alpha) * index1 + alpha * index2
-        conditioned_core = core_module.get_matrix(
-            torch.tensor([conditioned_t], device=device)
-        )
-
-        direct_latent = batch_depthwise_conv2d(encoded_content, direct_core)
-        conditioned_latent = batch_depthwise_conv2d(encoded_content, conditioned_core)
-        direct_output = linearizer.gy_inverse(direct_latent)
-        conditioned_output = linearizer.gy_inverse(conditioned_latent)
-
-        expected_direct_latent = (
-            1.0 - alpha
-        ) * endpoint_latent1 + alpha * endpoint_latent2
-        latent_linearity = error_metrics(direct_latent, expected_direct_latent)
-        direct_vs_conditioned_raw = error_metrics(direct_output, conditioned_output)
-        direct_vs_conditioned_clipped = error_metrics(
-            direct_output.clamp(0, 1), conditioned_output.clamp(0, 1)
-        )
-
-        direct_cores.append(direct_core.detach().cpu())
-        conditioned_cores.append(conditioned_core.detach().cpu())
-        direct_images.append(direct_output.detach().cpu())
-        conditioned_images.append(conditioned_output.detach().cpu())
-        abs_difference_images.append(
-            (direct_output - conditioned_output).abs().detach().cpu()
-        )
-        alpha_rows.append(
-            {
-                "alpha": alpha,
-                "conditioned_style_index": conditioned_t,
-                "direct_core_values": direct_core.detach().cpu().flatten().tolist(),
-                "conditioned_core_values": conditioned_core.detach()
-                .cpu()
-                .flatten()
-                .tolist(),
-                "direct_core_vs_conditioned_core": error_metrics(
-                    direct_core, conditioned_core
-                ),
-                "direct_latent_linearity_check": latent_linearity,
-                "direct_vs_conditioned_raw": direct_vs_conditioned_raw,
-                "direct_vs_conditioned_display_clipped": direct_vs_conditioned_clipped,
-                "direct_output": output_summary(direct_output),
-                "conditioned_output": output_summary(conditioned_output),
-            }
-        )
-
-    endpoint_checks = {
-        "alpha_0_direct_vs_conditioned": alpha_rows[0]["direct_vs_conditioned_raw"],
-        "alpha_1_direct_vs_conditioned": alpha_rows[-1]["direct_vs_conditioned_raw"],
-        style1: endpoint_target_metrics(
-            direct_images[0], reference_dir / f"{style1}.png"
-        ),
-        style2: endpoint_target_metrics(
-            direct_images[-1], reference_dir / f"{style2}.png"
-        ),
-    }
-
-    internal_rows = alpha_rows[1:-1]
-    pair_metrics: dict[str, Any] = {
-        "style_1": {"name": style1, "index": index1},
-        "style_2": {"name": style2, "index": index2},
-        "endpoint_core_shape": list(core1.shape),
-        "endpoint_core_1_values": core1.detach().cpu().flatten().tolist(),
-        "endpoint_core_2_values": core2.detach().cpu().flatten().tolist(),
-        "endpoint_core_1_sha256": tensor_sha256(core1.float()),
-        "endpoint_core_2_sha256": tensor_sha256(core2.float()),
-        "endpoint_checks": endpoint_checks,
-        "per_alpha": alpha_rows,
-        "direct_path_smoothness_raw": path_smoothness(direct_images, alphas),
-        "direct_path_smoothness_display_clipped": path_smoothness(
-            [image.clamp(0, 1) for image in direct_images], alphas
-        ),
-        "conditioned_path_smoothness_raw": path_smoothness(conditioned_images, alphas),
-        "conditioned_path_smoothness_display_clipped": path_smoothness(
-            [image.clamp(0, 1) for image in conditioned_images], alphas
-        ),
-        "direct_core_path_smoothness": core_path_smoothness(direct_cores),
-        "conditioned_core_path_smoothness": core_path_smoothness(conditioned_cores),
-        "internal_direct_vs_conditioned": {
-            "mean_raw_rms": float(
-                np.mean(
-                    [row["direct_vs_conditioned_raw"]["rms"] for row in internal_rows]
-                )
-            ),
-            "max_raw_rms": max(
-                (row["direct_vs_conditioned_raw"]["rms"] for row in internal_rows),
-                default=0.0,
-            ),
-            "max_raw_max_abs": max(
-                (row["direct_vs_conditioned_raw"]["max_abs"] for row in internal_rows),
-                default=0.0,
-            ),
-            "mean_core_rms": float(
-                np.mean(
-                    [
-                        row["direct_core_vs_conditioned_core"]["rms"]
-                        for row in internal_rows
-                    ]
-                )
-            ),
-            "max_core_rms": max(
-                (
-                    row["direct_core_vs_conditioned_core"]["rms"]
-                    for row in internal_rows
-                ),
-                default=0.0,
-            ),
-        },
-        "maximum_direct_latent_linearity_error": max(
-            row["direct_latent_linearity_check"]["max_abs"] for row in alpha_rows
-        ),
-    }
-    return pair_metrics, direct_images, conditioned_images, abs_difference_images
-
-
-def save_figure(
-    path: Path,
-    pair_outputs: list[
-        tuple[tuple[str, str], list[Tensor], list[Tensor], list[Tensor]]
-    ],
-    alphas: list[float],
-    dpi: int,
-) -> None:
-    import matplotlib
-
-    matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
-
-    rows_per_pair = 3
-    figure, axes = plt.subplots(
-        rows_per_pair * len(pair_outputs),
-        len(alphas),
-        figsize=(2.05 * len(alphas), 2.0 * rows_per_pair * len(pair_outputs)),
-        squeeze=False,
-    )
-
-    for pair_index, (pair, direct, conditioned, differences) in enumerate(pair_outputs):
-        style1, style2 = pair
-        base_row = pair_index * rows_per_pair
-        for column, alpha in enumerate(alphas):
-            panels = (
-                (direct[column], "direct core chord", "gray"),
-                (conditioned[column], "conditioned index", "gray"),
-                (differences[column] * 4.0, "4x |direct-conditioned|", "magma"),
-            )
-            for offset, (tensor, row_label, color_map) in enumerate(panels):
-                axis = axes[base_row + offset, column]
-                image = tensor[0].permute(1, 2, 0).clamp(0, 1).numpy()
-                if color_map == "magma":
-                    image = image.mean(axis=2)
-                    axis.imshow(image, cmap=color_map, vmin=0, vmax=1)
-                else:
-                    axis.imshow(image)
-                axis.set_xticks([])
-                axis.set_yticks([])
-                if offset == 0:
-                    endpoint = ""
-                    if column == 0:
-                        endpoint = f"\n{style1}"
-                    elif column == len(alphas) - 1:
-                        endpoint = f"\n{style2}"
-                    axis.set_title(f"alpha={alpha:g}{endpoint}", fontsize=9)
-                if column == 0:
-                    axis.set_ylabel(f"{style1} -> {style2}\n{row_label}", fontsize=9)
-
-    figure.suptitle(
-        "Direct Linearizer core interpolation versus nonlinear conditioned-index path\n"
-        r"$A_\alpha=(1-\alpha)A_1+\alpha A_2$ with one shared $g_x(x)$ and fixed $g_y^{-1}$",
-        fontsize=15,
-    )
-    figure.tight_layout(rect=(0, 0, 1, 0.965), h_pad=0.8, w_pad=0.25)
-    figure.savefig(path, dpi=dpi, bbox_inches="tight")
-    plt.close(figure)
-
-
-def environment_metadata(device: torch.device) -> dict[str, Any]:
-    return {
-        "python": sys.version.split()[0],
-        "platform": platform.platform(),
-        "torch": torch.__version__,
-        "numpy": np.__version__,
-        "device": str(device),
-        "cuda_available": torch.cuda.is_available(),
-        "cuda_version": torch.version.cuda,
-        "cuda_device_name": (
-            torch.cuda.get_device_name(device) if device.type == "cuda" else None
-        ),
-        "deterministic_algorithms": torch.are_deterministic_algorithms_enabled(),
-    }
-
-
-def main(argv: Iterable[str] | None = None) -> int:
-    args = parse_args(argv)
-    seed_everything(args.seed)
-    device = choose_device(args.device)
-    args.output_dir.mkdir(parents=True, exist_ok=True)
-    if not args.model_path.exists():
-        raise FileNotFoundError(args.model_path)
-    if not args.image_path.exists():
-        raise FileNotFoundError(args.image_path)
-
-    started = time.perf_counter()
-    print(f"device={device} seed={args.seed}", flush=True)
-    linearizer = torch.load(
-        args.model_path, map_location=device, weights_only=False
-    ).to(device)
-    linearizer.eval()
-    parameter_count = sum(parameter.numel() for parameter in linearizer.parameters())
-    content = load_rgb(args.image_path).unsqueeze(0).to(device)
-
-    with torch.inference_mode():
-        encoded_content = linearizer.gx(content)
-    print(
-        f"loaded={args.model_path} parameters={parameter_count} "
-        f"content_shape={tuple(content.shape)} encoded_gx_once=true",
-        flush=True,
-    )
-
-    all_pair_metrics: dict[str, Any] = {}
-    pair_outputs = []
-    for style1, style2 in args.pairs:
-        print(f"pair={style1}:{style2}", flush=True)
-        metrics, direct, conditioned, differences = evaluate_pair(
-            linearizer,
-            encoded_content,
-            style1,
-            style2,
-            args.alphas,
-            device,
-            args.image_path.parent,
-        )
-        key = f"{style1}_to_{style2}"
-        all_pair_metrics[key] = metrics
-        pair_outputs.append(((style1, style2), direct, conditioned, differences))
-        comparison = metrics["internal_direct_vs_conditioned"]
-        smoothness = metrics["direct_path_smoothness_display_clipped"]
-        print(
-            f"pair={key} internal_direct_vs_conditioned_mean_rms="
-            f"{comparison['mean_raw_rms']:.6e} max_rms={comparison['max_raw_rms']:.6e} "
-            f"direct_path_to_chord={smoothness['path_to_chord_ratio']:.6f} "
-            f"latent_linearity_max={metrics['maximum_direct_latent_linearity_error']:.3e}",
-            flush=True,
-        )
-
-    figure_path = args.output_dir / "direct_core_blend_vs_conditioned.png"
-    save_figure(figure_path, pair_outputs, args.alphas, args.dpi)
-
-    elapsed = time.perf_counter() - started
-    endpoint_max = max(
-        max(
-            pair["endpoint_checks"]["alpha_0_direct_vs_conditioned"]["max_abs"],
-            pair["endpoint_checks"]["alpha_1_direct_vs_conditioned"]["max_abs"],
-        )
-        for pair in all_pair_metrics.values()
-    )
-    direct_latent_max = max(
-        pair["maximum_direct_latent_linearity_error"]
-        for pair in all_pair_metrics.values()
-    )
-    results: dict[str, Any] = {
-        "schema_version": 1,
-        "claim": (
-            "With fixed shared encoders, Linearizer style cores can be directly "
-            "interpolated as A_alpha=(1-alpha)A1+alpha*A2."
-        ),
-        "distinction_under_test": (
-            "Direct matrix interpolation is compared against the released script's "
-            "nonlinear hypernetwork path obtained by interpolating scalar style index t."
-        ),
-        "protocol": {
-            "seed": args.seed,
-            "alphas": args.alphas,
-            "pairs": [list(pair) for pair in args.pairs],
-            "gx_evaluations": 1,
-            "shared_gx_and_gy_fixed": True,
-            "direct_core_formula": "A_alpha=(1-alpha)*A_style1+alpha*A_style2",
-            "conditioned_index_formula": "t_alpha=(1-alpha)*t_style1+alpha*t_style2",
-            "output_formula": "y=g_y_inverse(depthwise_conv(g_x(x), A))",
-        },
-        "model": {
-            "path": str(args.model_path.resolve()),
-            "sha256": file_sha256(args.model_path),
-            "parameter_count": parameter_count,
-            "core_module": type(linearizer.linear_network).__name__,
-        },
-        "content": {
-            "path": str(args.image_path.resolve()),
-            "sha256": file_sha256(args.image_path),
-            "shape": list(content.shape),
-            "encoded_shape": list(encoded_content.shape),
-            "encoded_sha256_float32": tensor_sha256(encoded_content.float()),
-        },
-        "pairs": all_pair_metrics,
-        "summary": {
-            "endpoint_direct_vs_conditioned_worst_max_abs": endpoint_max,
-            "direct_latent_linearity_worst_max_abs": direct_latent_max,
-            "elapsed_seconds": elapsed,
-        },
-        "environment": environment_metadata(device),
-        "artifacts": {
-            "figure": figure_path.name,
-            "figure_sha256": file_sha256(figure_path),
-            "metrics": "metrics.json",
-        },
-    }
-    metrics_path = args.output_dir / "metrics.json"
-    with metrics_path.open("w", encoding="utf-8") as handle:
-        json.dump(results, handle, indent=2, sort_keys=True)
-        handle.write("\n")
-
-    print(
-        f"RESULT endpoint_worst_max={endpoint_max:.3e} "
-        f"latent_linearity_worst_max={direct_latent_max:.3e} "
-        f"elapsed_seconds={elapsed:.2f}",
-        flush=True,
-    )
-    print(f"FIGURE={figure_path.resolve()}", flush=True)
-    print(f"METRICS_JSON={metrics_path.resolve()}", flush=True)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
-
-````
-
-
-````output
-device=cuda seed=25191
-loaded=/home/ubuntu/samuel/linearizer-repro/Linearizer/style_transfer/outputs/07_16_12_26_15/model.pth parameters=3698544 content_shape=(1, 3, 256, 256) encoded_gx_once=true
-pair=candy:rain_princess
-/home/ubuntu/samuel/linearizer-repro/Linearizer/style_transfer/modules/linear_network.py:31: UserWarning: Using padding='same' with even kernel lengths and odd dilation may require a zero-padded copy of the input be created (Triggered internally at ../aten/src/ATen/native/Convolution.cpp:1036.)
-  y = F.conv2d(x_, w_, bias=None, stride=stride, padding=padding,
-pair=candy_to_rain_princess internal_direct_vs_conditioned_mean_rms=1.272126e-02 max_rms=2.245972e-02 direct_path_to_chord=1.203732 latent_linearity_max=5.960e-07
-pair=mosaic:udnie
-pair=mosaic_to_udnie internal_direct_vs_conditioned_mean_rms=1.365280e-01 max_rms=1.885035e-01 direct_path_to_chord=1.424578 latent_linearity_max=5.960e-07
-RESULT endpoint_worst_max=0.000e+00 latent_linearity_worst_max=5.960e-07 elapsed_seconds=55.15
-FIGURE=/home/ubuntu/samuel/linearizer-repro/outputs/claim5_direct_core_blend_logged/direct_core_blend_vs_conditioned.png
-METRICS_JSON=/home/ubuntu/samuel/linearizer-repro/outputs/claim5_direct_core_blend_logged/metrics.json
-
-````