AlbumentationsX 2.1.1

Pipeline replay: save exact sampled params and reproduce any augmentation

Every transform now tracks the exact scalar values that were actually used in a run — not the ranges, but the concrete numbers sampled from them. Enable with save_applied_params=True on Compose, then replay or log them:

import albumentations as A
import numpy as np

transform = A.Compose([
    A.RandomBrightnessContrast(brightness_limit=(-0.3, 0.3), p=1),
    A.GaussNoise(std_range=(0.1, 0.4), p=0.9),
    A.HorizontalFlip(p=0.5),
], save_applied_params=True)

result = transform(image=image)

# Which transforms ran, and with what exact values?
print(result["applied_transforms"])
# [
#   ("RandomBrightnessContrast",
#    {"brightness_limit": 0.21, "contrast_limit": -0.08, ...}),
#   ("GaussNoise",
#    {"std_range": 0.27, "mean_range": 0.0, ...}),
# ]

# Reconstruct a deterministic p=1.0 pipeline that reproduces the same effect:
replay = A.Compose.from_applied_transforms(result["applied_transforms"])
result2 = replay(image=image)  # same pixel output for constructor-level randomness

What applied_config contains: all constructor parameters merged with the concrete sampled overrides — suitable for logging, debugging, or writing to a database alongside training annotations.

Scope: from_applied_transforms fixes constructor-level randomness (brightness factor, noise sigma, etc.). Transforms with internal spatial randomness (random crop offsets, dropout mask positions) may still vary — those depend on RNG state beyond the constructor params.

New transform: LetterBox

Scale-to-fit with padding — the standard YOLO preprocessing step, equivalent to LongestMaxSize + PadIfNeeded in a single transform.

transform = A.Compose([
    A.LetterBox(size=(480, 640), fill=114, fill_mask=0, p=1.0)
], bbox_params=A.BboxParams(coord_format="pascal_voc", label_fields=["labels"]))

# Wide image (800×600) → fits width, pads top/bottom
result = transform(image=image, mask=mask, bboxes=bboxes, labels=labels)
# result["image"].shape == (480, 640, 3)

# Tall image (600×800) → fits height, pads left/right
result2 = transform(image=tall_image, mask=tall_mask, bboxes=tall_bboxes, labels=labels)
# result2["image"].shape == (480, 640, 3)

• Preserves aspect ratio; pads the short side with a constant color (fill=114 is the YOLO convention).
• position controls where the resized image is placed on the canvas: "center" (default), "top_left", "top_right", "bottom_left", "bottom_right", or "random".
• Full target support: images, masks, HBB and OBB bounding boxes, keypoints, volumes.

Performance: albucore 0.1.2 speeds up mean/std-based normalization and brightness/contrast

albucore 0.1.2 replaces numpy.mean / numpy.std calls in the hot path with optimized C++ reductions (albucore.mean, albucore.std), and adds faster implementations of add_weighted, multiply_by_constant, add_vector, normalize, power, and multiply_by_vector.

The impact on real transforms (measured against albucore 0.0.41 on identical hardware):

Normalize(normalization="image") — global-mean normalization

Normalize(normalization="image_per_channel") — per-channel normalization

RandomBrightnessContrast(brightness_by_max=False) — mean-based brightness/contrast

Uses mean and multiply_add from albucore:

Halftone — mean-based luminance computation per cell

Internal refactoring: pixel module split

The 7 800-line pixel/transforms.py was split into focused modules — no public API change, all names continue to import from albumentations as before:

ChannelShuffle gains an optional channel_order parameter — pass a tuple to pin a fixed permutation. ChannelSwap is now a thin subclass that requires it.

Upgrade

pip install -U albumentationsx