diff --git a/.gitignore b/.gitignore index c56ae5a..5e66281 100644 --- a/.gitignore +++ b/.gitignore @@ -168,3 +168,5 @@ conda_build/ data/ .venv_* + +notebooks/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 4ea7193..d3bdacf 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -37,7 +37,7 @@ repos: - id: requirements-txt-fixer - repo: https://github.com/astral-sh/ruff-pre-commit # Ruff version. - rev: v0.7.2 + rev: v0.9.4 hooks: # Run the linter. - id: ruff @@ -54,7 +54,7 @@ repos: - id: python-use-type-annotations - id: text-unicode-replacement-char - repo: https://github.com/codespell-project/codespell - rev: v2.3.0 + rev: v2.4.1 hooks: - id: codespell additional_dependencies: ["tomli"] @@ -63,7 +63,7 @@ repos: hooks: - id: pyproject-fmt - repo: https://github.com/pre-commit/mirrors-mypy - rev: v1.13.0 + rev: v1.14.1 hooks: - id: mypy files: ^benchmark/ diff --git a/README.md b/README.md index b434dc6..d92d9f2 100644 --- a/README.md +++ b/README.md @@ -40,62 +40,90 @@ This benchmark suite measures the throughput and performance characteristics of - Thread control settings for consistent single-threaded performance - Support for multiple image formats and loading methods -## Benchmark Results + +![Albumentations vs TorchVision vs Kornia](speedup_analysis.png) + +# Benchmark Results ### System Information -- Platform: macOS-15.0.1-arm64-arm-64bit +- Platform: macOS-15.1-arm64-arm-64bit - Processor: arm -- CPU Count: 10 -- Python Version: 3.12.7 +- CPU Count: 16 +- Python Version: 3.12.8 ### Benchmark Parameters -- Number of images: 1000 -- Runs per transform: 20 +- Number of images: 2000 +- Runs per transform: 5 - Max warmup iterations: 1000 ### Library Versions -- albumentations: 1.4.21 +- albumentations: 2.0.2 - augly: 1.0.0 - imgaug: 0.4.0 -- kornia: 0.7.3 +- kornia: 0.8.0 - torchvision: 0.20.1 ## Performance Comparison -| Transform | albumentations
1.4.21 | augly
1.0.0 | imgaug
0.4.0 | kornia
0.7.3 | torchvision
0.20.1 | -|:------------------|:---------------------------|:-----------------|:------------------|:------------------|:------------------------| -| HorizontalFlip | **8622 ± 891** | 4121 ± 1001 | 6162 ± 393 | 571 ± 84 | 861 ± 38 | -| VerticalFlip | **23951 ± 5013** | 7775 ± 1376 | 11663 ± 2258 | 1590 ± 100 | 3156 ± 402 | -| Rotate | 1163 ± 84 | 1095 ± 82 | **1224 ± 75** | 167 ± 11 | 160 ± 11 | -| Affine | **907 ± 49** | - | 890 ± 34 | 181 ± 6 | 129 ± 16 | -| Equalize | **852 ± 90** | - | 610 ± 35 | 184 ± 9 | 416 ± 44 | -| RandomCrop80 | **107764 ± 3630** | 25192 ± 5964 | 12343 ± 2013 | 1492 ± 22 | 28767 ± 858 | -| ShiftRGB | **2351 ± 276** | - | 1674 ± 63 | - | - | -| Resize | **2372 ± 156** | 632 ± 38 | 2025 ± 74 | 332 ± 18 | 180 ± 11 | -| RandomGamma | **9014 ± 371** | - | 2592 ± 143 | 128 ± 10 | - | -| Grayscale | **11373 ± 923** | 3359 ± 65 | 1849 ± 75 | 628 ± 75 | 1497 ± 317 | -| RandomPerspective | 401 ± 24 | - | **596 ± 38** | 98 ± 7 | 106 ± 4 | -| GaussianBlur | **1664 ± 144** | 235 ± 18 | 1043 ± 142 | 165 ± 12 | 82 ± 3 | -| MedianBlur | 847 ± 36 | - | **849 ± 32** | 4 ± 0 | - | -| MotionBlur | **3928 ± 742** | - | 663 ± 36 | 75 ± 6 | - | -| Posterize | **9034 ± 331** | - | 2400 ± 142 | 363 ± 69 | 3052 ± 380 | -| JpegCompression | **906 ± 40** | 754 ± 14 | 443 ± 79 | 69 ± 3 | 606 ± 42 | -| GaussianNoise | 183 ± 5 | 70 ± 1 | **204 ± 18** | 65 ± 2 | - | -| Elastic | 229 ± 17 | - | **251 ± 22** | 1 ± 0 | 3 ± 0 | -| Clahe | **471 ± 18** | - | 422 ± 12 | 90 ± 2 | - | -| Brightness | **9251 ± 709** | 1297 ± 42 | 742 ± 39 | 519 ± 15 | 449 ± 14 | -| Contrast | **9146 ± 1034** | 880 ± 9 | 510 ± 9 | 476 ± 116 | 358 ± 4 | -| CoarseDropout | **14488 ± 2108** | - | 653 ± 85 | 526 ± 86 | - | -| Blur | **5804 ± 305** | 243 ± 9 | 3857 ± 385 | - | - | -| ColorJitter | **700 ± 31** | 252 ± 15 | - | 50 ± 4 | 47 ± 2 | -| RandomResizedCrop | **2879 ± 158** | - | - | 321 ± 10 | 462 ± 47 | -| Normalize | **1349 ± 65** | - | - | 645 ± 40 | 528 ± 20 | -| PlankianJitter | **2155 ± 340** | - | - | 1023 ± 114 | - | -| HSV | **1243 ± 44** | - | - | - | - | -## Requirements +Number shows how many uint8 images per second can be processed on one CPU thread. Larger is better. + +| Transform | albumentations
2.0.2 | augly
1.0.0 | imgaug
0.4.0 | kornia
0.8.0 | torchvision
0.20.1 | +|:---------------------|:--------------------------|:-----------------|:------------------|:------------------|:------------------------| +| Resize | **3662 ± 54** | 1083 ± 21 | 2995 ± 70 | 645 ± 13 | 260 ± 9 | +| RandomCrop128 | **116784 ± 2222** | 45395 ± 934 | 21408 ± 622 | 2946 ± 42 | 31450 ± 249 | +| HorizontalFlip | **12649 ± 238** | 8808 ± 1012 | 9599 ± 495 | 1297 ± 13 | 2486 ± 107 | +| VerticalFlip | **24989 ± 904** | 16830 ± 1653 | 19935 ± 1708 | 2872 ± 37 | 4696 ± 161 | +| Rotate | **3066 ± 83** | 1739 ± 105 | 2574 ± 10 | 256 ± 2 | 258 ± 4 | +| Affine | **1503 ± 29** | - | 1328 ± 16 | 248 ± 6 | 188 ± 2 | +| Perspective | **1222 ± 16** | - | 908 ± 8 | 154 ± 3 | 147 ± 5 | +| Elastic | 359 ± 7 | - | **395 ± 14** | 1 ± 0 | 3 ± 0 | +| ChannelShuffle | **8162 ± 180** | - | 1252 ± 26 | 1328 ± 44 | 4417 ± 234 | +| Grayscale | **37212 ± 1856** | 6088 ± 107 | 3100 ± 24 | 1201 ± 52 | 2600 ± 23 | +| GaussianBlur | 943 ± 11 | 387 ± 4 | **1460 ± 23** | 254 ± 5 | 127 ± 4 | +| GaussianNoise | 234 ± 7 | - | **263 ± 9** | 125 ± 1 | - | +| Invert | **35494 ± 17186** | - | 3682 ± 79 | 2881 ± 43 | 4244 ± 30 | +| Posterize | **14146 ± 1381** | - | 3111 ± 95 | 836 ± 30 | 4247 ± 26 | +| Solarize | **12920 ± 1097** | - | 3843 ± 80 | 263 ± 6 | 1032 ± 14 | +| Sharpen | **2375 ± 38** | - | 1101 ± 30 | 201 ± 2 | 220 ± 3 | +| Equalize | **1303 ± 64** | - | 814 ± 11 | 306 ± 1 | 795 ± 3 | +| JpegCompression | **1354 ± 23** | 1202 ± 19 | 687 ± 26 | 120 ± 1 | 889 ± 7 | +| RandomGamma | **12631 ± 1159** | - | 3504 ± 72 | 230 ± 3 | - | +| MedianBlur | **1259 ± 8** | - | 1152 ± 14 | 6 ± 0 | - | +| MotionBlur | **3608 ± 18** | - | 928 ± 37 | 159 ± 1 | - | +| CLAHE | **649 ± 13** | - | 555 ± 14 | 165 ± 3 | - | +| Brightness | **11254 ± 418** | 2108 ± 32 | 1076 ± 32 | 1127 ± 27 | 854 ± 13 | +| Contrast | **11255 ± 242** | 1379 ± 25 | 717 ± 5 | 1109 ± 41 | 602 ± 13 | +| CoarseDropout | **15760 ± 594** | - | 1190 ± 22 | - | - | +| Blur | **7403 ± 114** | 386 ± 4 | 5381 ± 125 | 265 ± 11 | - | +| Saturation | **1581 ± 127** | - | 495 ± 3 | 155 ± 2 | - | +| Shear | **1336 ± 18** | - | 1244 ± 14 | 261 ± 1 | - | +| ColorJitter | **968 ± 52** | 418 ± 5 | - | 104 ± 4 | 87 ± 1 | +| RandomResizedCrop | **4521 ± 17** | - | - | 661 ± 16 | 837 ± 37 | +| Pad | **31866 ± 530** | - | - | - | 4889 ± 183 | +| AutoContrast | **1534 ± 115** | - | - | 541 ± 8 | 344 ± 1 | +| Normalize | **1797 ± 190** | - | - | 1251 ± 14 | 1018 ± 7 | +| Erasing | **25411 ± 5727** | - | - | 1210 ± 27 | 3577 ± 49 | +| CenterCrop128 | **119630 ± 3484** | - | - | - | - | +| RGBShift | **3526 ± 128** | - | - | 896 ± 9 | - | +| PlankianJitter | **3351 ± 42** | - | - | 2150 ± 52 | - | +| HSV | **1277 ± 91** | - | - | - | - | +| ChannelDropout | **10988 ± 243** | - | - | 2283 ± 24 | - | +| LinearIllumination | 462 ± 52 | - | - | **708 ± 6** | - | +| CornerIllumination | **464 ± 45** | - | - | 452 ± 3 | - | +| GaussianIllumination | **670 ± 91** | - | - | 436 ± 13 | - | +| Hue | **1846 ± 193** | - | - | 150 ± 1 | - | +| PlasmaBrightness | **163 ± 1** | - | - | 85 ± 1 | - | +| PlasmaContrast | **138 ± 4** | - | - | 84 ± 0 | - | +| PlasmaShadow | 190 ± 3 | - | - | **216 ± 5** | - | +| Rain | **2121 ± 64** | - | - | 1493 ± 9 | - | +| SaltAndPepper | **2233 ± 35** | - | - | 480 ± 12 | - | +| Snow | **588 ± 32** | - | - | 143 ± 1 | - | +| OpticalDistortion | **687 ± 38** | - | - | 174 ± 0 | - | +| ThinPlateSpline | **75 ± 5** | - | - | 58 ± 0 | - | + The benchmark automatically creates isolated virtual environments for each library and installs the necessary dependencies. Base requirements: diff --git a/benchmark/transforms/albumentations_impl.py b/benchmark/transforms/albumentations_impl.py index a95814f..15c7dec 100644 --- a/benchmark/transforms/albumentations_impl.py +++ b/benchmark/transforms/albumentations_impl.py @@ -12,182 +12,240 @@ class AlbumentationsImpl: """Albumentations implementations of transforms""" + @staticmethod + def Resize(params: dict[str, Any]) -> A.BasicTransform: + return A.Resize( + height=params["target_size"], + width=params["target_size"], + interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, + p=1, + ) + + @staticmethod + def RandomCrop128(params: dict[str, Any]) -> A.BasicTransform: + return A.RandomCrop( + height=params["height"], + width=params["width"], + pad_if_needed=True, + p=1, + ) + + @staticmethod + def RandomResizedCrop(params: dict[str, Any]) -> A.BasicTransform: + return A.RandomResizedCrop( + size=(params["height"], params["width"]), + scale=params["scale"], + ratio=params["ratio"], + interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, + p=1, + ) + + @staticmethod + def CenterCrop128(params: dict[str, Any]) -> A.BasicTransform: + return A.CenterCrop( + height=params["height"], + width=params["width"], + pad_if_needed=True, + p=1, + ) + @staticmethod def HorizontalFlip(params: dict[str, Any]) -> A.BasicTransform: - return A.HorizontalFlip(**params) + return A.HorizontalFlip(p=1) @staticmethod def VerticalFlip(params: dict[str, Any]) -> A.BasicTransform: - return A.VerticalFlip(**params) + return A.VerticalFlip(p=1) + + @staticmethod + def Pad(params: dict[str, Any]) -> A.BasicTransform: + return A.Pad( + padding=params["padding"], + fill=params["fill"], + border_mode=cv2.BORDER_CONSTANT if params["border_mode"] == "constant" else cv2.BORDER_REFLECT, + p=1, + ) @staticmethod def Rotate(params: dict[str, Any]) -> A.BasicTransform: return A.Rotate( - limit=(params["angle"], params["angle"]), + limit=params["angle"], interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, - p=params["p"], + border_mode=cv2.BORDER_CONSTANT if params["mode"] == "constant" else cv2.BORDER_REFLECT, + fill=params["fill"], + p=1, ) @staticmethod def Affine(params: dict[str, Any]) -> A.BasicTransform: return A.Affine( rotate=params["angle"], - translate_percent=[x / 100 for x in params["shift"]], # convert to percentage + translate_px=params["shift"], scale=params["scale"], shear=params["shear"], interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, - p=params["p"], + border_mode=cv2.BORDER_CONSTANT if params["mode"] == "constant" else cv2.BORDER_REFLECT, + fill=params["fill"], + p=1, ) @staticmethod - def Clahe(params: dict[str, Any]) -> A.BasicTransform: - return A.CLAHE( - clip_limit=params["clip_limit"], - tile_grid_size=params["tile_grid_size"], - p=params["p"], + def Perspective(params: dict[str, Any]) -> A.BasicTransform: + return A.Perspective( + scale=params["scale"], + interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, + p=1, ) @staticmethod - def Equalize(params: dict[str, Any]) -> A.BasicTransform: - return A.Equalize(**params) + def Elastic(params: dict[str, Any]) -> A.BasicTransform: + return A.ElasticTransform( + alpha=params["alpha"], + sigma=params["sigma"], + interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, + approximate=params["approximate"], + same_dxdy=params["same_dxdy"], + p=1, + ) @staticmethod - def RandomCrop80(params: dict[str, Any]) -> A.BasicTransform: - return A.RandomCrop( - height=params["height"], - width=params["width"], - p=params["p"], + def ColorJitter(params: dict[str, Any]) -> A.BasicTransform: + return A.ColorJitter( + brightness=params["brightness"], + contrast=params["contrast"], + saturation=params["saturation"], + hue=params["hue"], + p=1, ) @staticmethod - def RandomResizedCrop(params: dict[str, Any]) -> A.BasicTransform: - return A.RandomResizedCrop( - height=params["height"], - width=params["width"], - scale=params["scale"], - ratio=params["ratio"], - interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, - p=params["p"], - ) + def ChannelShuffle(params: dict[str, Any]) -> A.BasicTransform: + return A.ChannelShuffle(p=1) @staticmethod - def ShiftRGB(params: dict[str, Any]) -> A.BasicTransform: + def Grayscale(params: dict[str, Any]) -> A.BasicTransform: + return A.ToGray(num_output_channels=params["num_output_channels"], p=1) + + @staticmethod + def RGBShift(params: dict[str, Any]) -> A.BasicTransform: shift = params["pixel_shift"] return A.RGBShift( r_shift_limit=shift, g_shift_limit=shift, b_shift_limit=shift, - p=params["p"], + p=1, ) @staticmethod - def Resize(params: dict[str, Any]) -> A.BasicTransform: - return A.Resize( - height=params["target_size"], - width=params["target_size"], - interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, - p=params["p"], + def GaussianBlur(params: dict[str, Any]) -> A.BasicTransform: + return A.GaussianBlur( + blur_limit=params["kernel_size"], # assuming square kernel + sigma_limit=(params["sigma"], params["sigma"]), + p=1, ) @staticmethod - def RandomGamma(params: dict[str, Any]) -> A.BasicTransform: - return A.RandomGamma( - gamma_limit=(params["gamma"], params["gamma"]), - p=params["p"], + def GaussianNoise(params: dict[str, Any]) -> A.BasicTransform: + return A.GaussNoise( + std_range=(params["std"], params["std"]), + mean_range=(params["mean"], params["mean"]), + per_channel=params["per_channel"], + p=1, ) @staticmethod - def Grayscale(params: dict[str, Any]) -> A.BasicTransform: - return A.ToGray(p=params["p"]) + def Invert(params: dict[str, Any]) -> A.BasicTransform: + return A.InvertImg(p=1) @staticmethod - def ColorJitter(params: dict[str, Any]) -> A.BasicTransform: - return A.ColorJitter( - brightness=params["brightness"], - contrast=params["contrast"], - saturation=params["saturation"], - hue=params["hue"], - p=params["p"], + def Posterize(params: dict[str, Any]) -> A.BasicTransform: + return A.Posterize( + num_bits=params["bits"], + p=1, ) @staticmethod - def PlankianJitter(params: dict[str, Any]) -> A.BasicTransform: - return A.PlanckianJitter( - mode=params["mode"], - p=params["p"], + def Solarize(params: dict[str, Any]) -> A.BasicTransform: + return A.Solarize( + threshold_range=(params["threshold"], params["threshold"]), + p=1, ) @staticmethod - def RandomPerspective(params: dict[str, Any]) -> A.BasicTransform: - return A.Perspective( - scale=params["scale"], - interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, - p=params["p"], + def Sharpen(params: dict[str, Any]) -> A.BasicTransform: + return A.Sharpen( + alpha=params["alpha"], + lightness=params["lightness"], + p=1, ) @staticmethod - def GaussianBlur(params: dict[str, Any]) -> A.BasicTransform: - return A.GaussianBlur( - blur_limit=params["kernel_size"][0], # assuming square kernel - sigma_limit=(params["sigma"], params["sigma"]), - p=params["p"], - ) + def AutoContrast(params: dict[str, Any]) -> A.BasicTransform: + return A.AutoContrast(p=1, method="pil") @staticmethod - def MedianBlur(params: dict[str, Any]) -> A.BasicTransform: - return A.MedianBlur( - blur_limit=(params["blur_limit"], params["blur_limit"]), - p=params["p"], - ) + def Equalize(params: dict[str, Any]) -> A.BasicTransform: + return A.Equalize(p=1) @staticmethod - def MotionBlur(params: dict[str, Any]) -> A.BasicTransform: - return A.MotionBlur( - blur_limit=params["kernel_size"], - p=params["p"], + def Normalize(params: dict[str, Any]) -> A.BasicTransform: + return A.Normalize( + mean=params["mean"], + std=params["std"], + p=1, ) @staticmethod - def Posterize(params: dict[str, Any]) -> A.BasicTransform: - return A.Posterize( - num_bits=params["bits"], - p=params["p"], + def Erasing(params: dict[str, Any]) -> A.BasicTransform: + return A.Erasing( + scale=params["scale"], + ratio=params["ratio"], + p=1, ) @staticmethod def JpegCompression(params: dict[str, Any]) -> A.BasicTransform: return A.ImageCompression( - quality_lower=params["quality"], - quality_upper=params["quality"], - p=params["p"], + quality_range=(params["quality"], params["quality"]), + p=1, ) @staticmethod - def GaussianNoise(params: dict[str, Any]) -> A.BasicTransform: - return A.GaussNoise( - var_limit=params["var"] * 255, # convert to 0-255 range - mean=params["mean"], - per_channel=params["per_channel"], - p=params["p"], + def RandomGamma(params: dict[str, Any]) -> A.BasicTransform: + return A.RandomGamma( + gamma_limit=(params["gamma"], params["gamma"]), + p=1, ) @staticmethod - def Elastic(params: dict[str, Any]) -> A.BasicTransform: - return A.ElasticTransform( - alpha=params["alpha"], - sigma=params["sigma"], - interpolation=cv2.INTER_LINEAR if params["interpolation"] == "bilinear" else cv2.INTER_NEAREST, - approximate=params["approximate"], - same_dxdy=params["same_dxdy"], - p=params["p"], + def PlankianJitter(params: dict[str, Any]) -> A.BasicTransform: + return A.PlanckianJitter( + mode=params["mode"], + p=1, ) @staticmethod - def Normalize(params: dict[str, Any]) -> A.BasicTransform: - return A.Normalize( - mean=params["mean"], - std=params["std"], - p=params["p"], + def MedianBlur(params: dict[str, Any]) -> A.BasicTransform: + return A.MedianBlur( + blur_limit=(params["blur_limit"], params["blur_limit"]), + p=1, + ) + + @staticmethod + def MotionBlur(params: dict[str, Any]) -> A.BasicTransform: + return A.MotionBlur( + blur_limit=params["kernel_size"], + angle_range=params["angle_range"], + direction_range=params["direction_range"], + p=1, + ) + + @staticmethod + def CLAHE(params: dict[str, Any]) -> A.BasicTransform: + return A.CLAHE( + clip_limit=params["clip_limit"], + tile_grid_size=params["tile_grid_size"], + p=1, ) @staticmethod @@ -195,7 +253,7 @@ def Brightness(params: dict[str, Any]) -> A.BasicTransform: return A.RandomBrightnessContrast( brightness_limit=params["brightness_limit"], contrast_limit=(0.0, 0.0), - p=params["p"], + p=1, ) @staticmethod @@ -203,14 +261,7 @@ def Contrast(params: dict[str, Any]) -> A.BasicTransform: return A.RandomBrightnessContrast( brightness_limit=(0.0, 0.0), contrast_limit=params["contrast_limit"], - p=params["p"], - ) - - @staticmethod - def Solarize(params: dict[str, Any]) -> A.BasicTransform: - return A.Solarize( - threshold=params["threshold"], - p=params["p"], + p=1, ) @staticmethod @@ -219,23 +270,103 @@ def CoarseDropout(params: dict[str, Any]) -> A.BasicTransform: hole_height_range=params["hole_height_range"], hole_width_range=params["hole_width_range"], num_holes_range=params["num_holes_range"], - p=params["p"], + p=1, ) @staticmethod def Blur(params: dict[str, Any]) -> A.BasicTransform: return A.Blur( - blur_limit=params["radius"], - p=params["p"], + blur_limit=(params["radius"], params["radius"]), + p=1, ) @staticmethod def HSV(params: dict[str, Any]) -> A.BasicTransform: + return A.HueSaturationValue( + hue_shift_limit=params["hue"] * 255, + sat_shift_limit=params["saturation"] * 255, + val_shift_limit=params["value"] * 255, + p=1, + ) + + @staticmethod + def ChannelDropout(params: dict[str, Any]) -> A.BasicTransform: + return A.ChannelDropout(p=1) + + @staticmethod + def LinearIllumination(params: dict[str, Any]) -> A.BasicTransform: + return A.Illumination(p=1, mode="linear", angle_range=(90, 90)) + + @staticmethod + def CornerIllumination(params: dict[str, Any]) -> A.BasicTransform: + return A.Illumination(p=1, mode="corner") + + @staticmethod + def GaussianIllumination(params: dict[str, Any]) -> A.BasicTransform: + return A.Illumination(p=1, mode="gaussian") + + @staticmethod + def Hue(params: dict[str, Any]) -> A.BasicTransform: return A.HueSaturationValue( hue_shift_limit=params["hue"], - sat_shift_limit=params["saturation"], - val_shift_limit=params["value"], - p=params["p"], + sat_shift_limit=0, + val_shift_limit=0, + p=1, + ) + + @staticmethod + def PlasmaBrightness(params: dict[str, Any]) -> A.BasicTransform: + return A.PlasmaBrightnessContrast(p=1, roughness=params["roughness"], contrast_range=(0.0, 0.0)) + + @staticmethod + def PlasmaContrast(params: dict[str, Any]) -> A.BasicTransform: + return A.PlasmaBrightnessContrast(p=1, roughness=params["roughness"], brightness_range=(0.0, 0.0)) + + @staticmethod + def PlasmaShadow(params: dict[str, Any]) -> A.BasicTransform: + return A.PlasmaShadow(p=1, roughness=params["roughness"]) + + @staticmethod + def Rain(params: dict[str, Any]) -> A.BasicTransform: + return A.RandomRain( + p=1, + drop_width=params["drop_width"], + brightness_coefficient=params["brightness_coefficient"], + ) + + @staticmethod + def SaltAndPepper(params: dict[str, Any]) -> A.BasicTransform: + return A.SaltAndPepper(p=1, amount=params["amount"], salt_vs_pepper=params["salt_vs_pepper"]) + + @staticmethod + def Saturation(params: dict[str, Any]) -> A.BasicTransform: + sat_shift_limit = params["saturation_factor"] * 255 + return A.HueSaturationValue(p=1, hue_shift_limit=0, sat_shift_limit=sat_shift_limit, val_shift_limit=0) + + @staticmethod + def Snow(params: dict[str, Any]) -> A.BasicTransform: + return A.RandomSnow(p=1, snow_point_range=params["snow_point_range"]) + + @staticmethod + def OpticalDistortion(params: dict[str, Any]) -> A.BasicTransform: + return A.OpticalDistortion(p=1, distort_limit=params["distort_limit"]) + + @staticmethod + def Shear(params: dict[str, Any]) -> A.BasicTransform: + return A.Affine( + p=1, + shear=params["shear"], + interpolation=cv2.INTER_LINEAR, + border_mode=cv2.BORDER_CONSTANT, + fill=0, + ) + + @staticmethod + def ThinPlateSpline(params: dict[str, Any]) -> A.BasicTransform: + return A.ThinPlateSpline( + p=1, + num_control_points=params["num_control_points"], + scale_range=(params["distortion_scale"], params["distortion_scale"]), ) @staticmethod diff --git a/benchmark/transforms/augly_impl.py b/benchmark/transforms/augly_impl.py index 4baee26..fecca06 100644 --- a/benchmark/transforms/augly_impl.py +++ b/benchmark/transforms/augly_impl.py @@ -13,11 +13,11 @@ class AuglyImpl: @staticmethod def HorizontalFlip(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: - return imaugs.HFlip(p=params["p"]) + return imaugs.HFlip(p=1) @staticmethod def VerticalFlip(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: - return imaugs.VFlip(p=params["p"]) + return imaugs.VFlip(p=1) @staticmethod def Rotate(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: @@ -25,11 +25,11 @@ def Rotate(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: return imaugs.RandomRotation( min_degrees=params["angle"], max_degrees=params["angle"], - p=params["p"], + p=1, ) @staticmethod - def RandomCrop80(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: + def RandomCrop128(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: # Augly uses relative coordinates (0-1) # Using fixed values as augly's crop works differently return imaugs.Crop( @@ -37,7 +37,7 @@ def RandomCrop80(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: y1=0.25, x2=0.75, y2=0.75, - p=params["p"], + p=1, ) @staticmethod @@ -46,12 +46,12 @@ def Resize(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: width=params["target_size"], height=params["target_size"], resample=Image.BILINEAR if params["interpolation"] == "bilinear" else Image.NEAREST, - p=params["p"], + p=1, ) @staticmethod def Grayscale(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: - return imaugs.Grayscale(p=params["p"]) + return imaugs.Grayscale(p=1) @staticmethod def ColorJitter(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: @@ -59,21 +59,21 @@ def ColorJitter(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: brightness_factor=params["brightness"], contrast_factor=params["contrast"], saturation_factor=params["saturation"], - p=params["p"], + p=1, ) @staticmethod def GaussianBlur(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: return imaugs.Blur( radius=params["sigma"], - p=params["p"], + p=1, ) @staticmethod def JpegCompression(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: return imaugs.EncodingQuality( quality=params["quality"], - p=params["p"], + p=1, ) @staticmethod @@ -81,14 +81,14 @@ def GaussianNoise(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: return imaugs.RandomNoise( mean=params["mean"], var=params["var"], - p=params["p"], + p=1, ) @staticmethod def Blur(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: return imaugs.Blur( radius=params["radius"], - p=params["p"], + p=1, ) @staticmethod @@ -96,14 +96,14 @@ def Brightness(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: return imaugs.RandomBrightness( min_factor=params["brightness_limit"][0], max_factor=params["brightness_limit"][1], - p=params["p"], + p=1, ) @staticmethod def Contrast(params: dict[str, Any]) -> imaugs.transforms.BaseTransform: return imaugs.Contrast( factor=params["contrast_limit"][0], - p=params["p"], + p=1, ) @staticmethod diff --git a/benchmark/transforms/imgaug_impl.py b/benchmark/transforms/imgaug_impl.py index d4b4448..2f020ec 100644 --- a/benchmark/transforms/imgaug_impl.py +++ b/benchmark/transforms/imgaug_impl.py @@ -15,11 +15,11 @@ class ImgaugImpl: @staticmethod def HorizontalFlip(params: dict[str, Any]) -> iaa.Augmenter: - return iaa.Fliplr(p=params["p"]) + return iaa.Fliplr(p=1) @staticmethod def VerticalFlip(params: dict[str, Any]) -> iaa.Augmenter: - return iaa.Flipud(p=params["p"]) + return iaa.Flipud(p=1) @staticmethod def Rotate(params: dict[str, Any]) -> iaa.Augmenter: @@ -44,7 +44,7 @@ def Equalize(params: dict[str, Any]) -> iaa.Augmenter: return iaa.AllChannelsHistogramEqualization() @staticmethod - def RandomCrop80(params: dict[str, Any]) -> iaa.Augmenter: + def RandomCrop128(params: dict[str, Any]) -> iaa.Augmenter: return iaa.CropToFixedSize(width=params["width"], height=params["height"]) @staticmethod @@ -70,7 +70,7 @@ def Grayscale(params: dict[str, Any]) -> iaa.Augmenter: return iaa.Grayscale(alpha=1.0) @staticmethod - def RandomPerspective(params: dict[str, Any]) -> iaa.Augmenter: + def Perspective(params: dict[str, Any]) -> iaa.Augmenter: return iaa.PerspectiveTransform( scale=params["scale"], mode=params.get("mode", "replicate"), @@ -87,7 +87,7 @@ def MedianBlur(params: dict[str, Any]) -> iaa.Augmenter: @staticmethod def MotionBlur(params: dict[str, Any]) -> iaa.Augmenter: - return iaa.MotionBlur(k=params["kernel_size"], angle=[params["angle"]], direction=params["direction"]) + return iaa.MotionBlur(k=params["kernel_size"], angle=params["angle_range"]) @staticmethod def Posterize(params: dict[str, Any]) -> iaa.Augmenter: @@ -101,7 +101,7 @@ def JpegCompression(params: dict[str, Any]) -> iaa.Augmenter: def GaussianNoise(params: dict[str, Any]) -> iaa.Augmenter: return iaa.AdditiveGaussianNoise( loc=params["mean"], - scale=(0, params["var"]), + scale=(0, params["std"]), per_channel=params["per_channel"], ) @@ -114,7 +114,7 @@ def Elastic(params: dict[str, Any]) -> iaa.Augmenter: ) @staticmethod - def Clahe(params: dict[str, Any]) -> iaa.Augmenter: + def CLAHE(params: dict[str, Any]) -> iaa.Augmenter: return iaa.AllChannelsCLAHE(clip_limit=params["clip_limit"], tile_grid_size_px=params["tile_grid_size"]) @staticmethod @@ -133,6 +133,33 @@ def Brightness(params: dict[str, Any]) -> iaa.Augmenter: def Contrast(params: dict[str, Any]) -> iaa.Augmenter: return iaa.AddToHueAndSaturation(value=int(params["contrast_limit"][0] * 100)) + @staticmethod + def Invert(params: dict[str, Any]) -> iaa.Augmenter: + return iaa.Invert(1.0) + + @staticmethod + def Sharpen(params: dict[str, Any]) -> iaa.Augmenter: + return iaa.Sharpen( + alpha=(params["alpha"][0], params["alpha"][1]), + lightness=(params["lightness"][0], params["lightness"][1]), + ) + + @staticmethod + def Solarize(params: dict[str, Any]) -> iaa.Augmenter: + return iaa.Solarize(threshold=params["threshold"] * 255) # Convert from [0,1] to [0,255] + + @staticmethod + def ChannelShuffle(params: dict[str, Any]) -> iaa.Augmenter: + return iaa.ChannelShuffle(1.0) + + @staticmethod + def Saturation(params: dict[str, Any]) -> iaa.Augmenter: + return iaa.MultiplySaturation(mul=params["saturation_factor"]) + + @staticmethod + def Shear(params: dict[str, Any]) -> iaa.Augmenter: + return iaa.ShearX(shear=params["shear"]) + @staticmethod def __call__(transform: iaa.Augmenter, image: np.ndarray) -> np.ndarray: """Apply the transform to the image""" diff --git a/benchmark/transforms/kornia_impl.py b/benchmark/transforms/kornia_impl.py index 4c54baa..3a30865 100644 --- a/benchmark/transforms/kornia_impl.py +++ b/benchmark/transforms/kornia_impl.py @@ -1,5 +1,6 @@ from typing import Any +import kornia import kornia.augmentation as Kaug import torch @@ -10,205 +11,347 @@ class KorniaImpl: """Kornia implementations of transforms""" @staticmethod - def HorizontalFlip(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomHorizontalFlip(**params) + def ColorJitter(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.ColorJitter( + brightness=params["brightness"], + contrast=params["contrast"], + saturation=params["saturation"], + hue=params["hue"], + p=1, + ) @staticmethod - def VerticalFlip(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomVerticalFlip(**params) + def AutoContrast(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomAutoContrast(p=1) @staticmethod - def Rotate(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - # Convert degrees to radians for rotation - angle = torch.tensor(params["angle"]) * (torch.pi / 180.0) - return Kaug.RandomRotation( - degrees=angle, - resample="bilinear", - p=params["p"], + def Blur(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomBoxBlur( + p=1, + kernel_size=(params["radius"], params["radius"]), + border_type=params["border_mode"], ) @staticmethod - def Affine(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomAffine( - degrees=params["angle"], - translate=0.1, - scale=[params["scale"], params["scale"]], - shear=params["shear"], - p=params["p"], + def Brightness(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomBrightness( + brightness=params["brightness_limit"], + p=1, ) @staticmethod - def Clahe(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomClahe( - clip_limit=params["clip_limit"], - grid_size=params["tile_grid_size"], - p=params["p"], - ) + def ChannelDropout(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomChannelDropout(p=1) @staticmethod - def Equalize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomEqualize(**params) + def ChannelShuffle(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomChannelShuffle(p=1) @staticmethod - def RandomCrop80(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomCrop( - size=(params["height"], params["width"]), - p=params["p"], - ) + def CLAHE(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomClahe(p=1, clip_limit=params["clip_limit"], grid_size=params["tile_grid_size"]) @staticmethod - def RandomResizedCrop(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomResizedCrop( - size=(params["height"], params["width"]), - scale=params["scale"], - ratio=params["ratio"], - p=params["p"], + def Contrast(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomContrast( + contrast=params["contrast_limit"], + p=1, ) @staticmethod - def Resize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.Resize( - size=(params["target_size"], params["target_size"]), - p=params["p"], - ) + def Equalize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomEqualize(p=1) @staticmethod def RandomGamma(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - gamma = params["gamma"] / 100 # Convert to kornia scale + gamma = params["gamma"] / 100 return Kaug.RandomGamma( gamma=(gamma, gamma), - p=params["p"], + p=1, ) @staticmethod - def Grayscale(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomGrayscale(p=params["p"]) + def GaussianBlur(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomGaussianBlur( + kernel_size=params["kernel_size"], + sigma=(params["sigma"], params["sigma"]), + p=1, + ) @staticmethod - def ColorJitter(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.ColorJitter( - brightness=params["brightness"], - contrast=params["contrast"], - saturation=params["saturation"], - hue=params["hue"], - p=params["p"], + def LinearIllumination(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomLinearIllumination( + gain=params["gain"], + p=1, ) @staticmethod - def PlankianJitter(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomPlanckianJitter( - mode=params["mode"], - p=params["p"], + def CornerIllumination(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomLinearCornerIllumination( + gain=params["gain"], + p=1, ) @staticmethod - def RandomPerspective(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomPerspective( - distortion_scale=params["scale"][1], # Using max scale - p=params["p"], + def GaussianIllumination(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomGaussianIllumination( + gain=params["gain"], + p=1, ) @staticmethod - def GaussianBlur(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomGaussianBlur( - kernel_size=params["kernel_size"], - sigma=(params["sigma"], params["sigma"]), - p=params["p"], + def GaussianNoise(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomGaussianNoise( + mean=params["mean"], + std=params["std"], + p=1, + ) + + @staticmethod + def Grayscale(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomGrayscale(p=1) + + @staticmethod + def Hue(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomHue( + hue=params["hue"], + p=1, + ) + + @staticmethod + def Invert(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomInvert(p=1) + + @staticmethod + def JpegCompression(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomJPEG( + jpeg_quality=params["quality"], + p=1, ) @staticmethod def MedianBlur(params: dict[str, Any]) -> Kaug.AugmentationBase2D: kernel_size = params["blur_limit"] - if kernel_size % 2 == 0: - kernel_size += 1 # Ensure odd kernel size return Kaug.RandomMedianBlur( kernel_size=(kernel_size, kernel_size), - p=params["p"], + p=1, ) @staticmethod def MotionBlur(params: dict[str, Any]) -> Kaug.AugmentationBase2D: return Kaug.RandomMotionBlur( kernel_size=params["kernel_size"], - angle=params["angle"], - direction=params["direction"], - p=params["p"], + angle=params["angle_range"], + direction=params["direction_range"], + p=1, ) @staticmethod - def Posterize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomPosterize( - bits=params["bits"], - p=params["p"], + def PlankianJitter(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomPlanckianJitter( + mode=params["mode"], + p=1, ) @staticmethod - def JpegCompression(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomJPEG( - jpeg_quality=params["quality"], - p=params["p"], + def PlasmaBrightness(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomPlasmaBrightness( + roughness=(params["roughness"], params["roughness"]), + p=1, ) @staticmethod - def Elastic(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - sigma = torch.tensor([params["sigma"], params["sigma"]]).float() - alpha = torch.tensor([params["alpha"], params["alpha"]]).float() - return Kaug.RandomElasticTransform( - alpha=alpha, - sigma=sigma, - p=params["p"], + def PlasmaContrast(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomPlasmaContrast( + roughness=(params["roughness"], params["roughness"]), + p=1, ) @staticmethod - def Normalize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.Normalize( - mean=params["mean"], - std=params["std"], - p=params["p"], + def PlasmaShadow(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomPlasmaShadow( + roughness=(params["roughness"], params["roughness"]), + p=1, ) @staticmethod - def Brightness(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomBrightness( - brightness=params["brightness_limit"], - p=params["p"], + def Rain(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomRain( + drop_width=(params["drop_width"], params["drop_width"]), + drop_height=(params["drop_height"], params["drop_height"]), + p=1, ) @staticmethod - def Contrast(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomContrast( - contrast=params["contrast_limit"], - p=params["p"], + def RGBShift(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomRGBShift( + r_shift_limit=params["pixel_shift"] / 255.0, + g_shift_limit=params["pixel_shift"] / 255.0, + b_shift_limit=params["pixel_shift"] / 255.0, + p=1, ) @staticmethod - def GaussianNoise(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomGaussianNoise( - mean=params["mean"], - std=params["var"], - p=params["p"], + def SaltAndPepper(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomSaltAndPepperNoise( + amount=params["amount"], + salt_vs_pepper=params["salt_vs_pepper"], + p=1, ) @staticmethod - def RGBShift(params: dict[str, Any]) -> Kaug.AugmentationBase2D: - return Kaug.RandomRGBShift( - r_shift_limit=params["r_shift_limit"] / 255.0, - g_shift_limit=params["g_shift_limit"] / 255.0, - b_shift_limit=params["b_shift_limit"] / 255.0, - p=params["p"], + def Saturation(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomSaturation( + saturation=params["saturation_factor"], + p=1, + ) + + @staticmethod + def Sharpen(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomSharpness( + p=1, + ) + + @staticmethod + def Snow(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomSnow( + snow_coefficient=params["snow_point_range"], + p=1, ) @staticmethod def Solarize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: return Kaug.RandomSolarize( - threshold=params["threshold"] / 255.0, - p=params["p"], + thresholds=params["threshold"], + p=1, + ) + + @staticmethod + def CenterCrop128(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.CenterCrop( + size=(params["height"], params["width"]), + pad_if_needed=True, + p=1, + ) + + @staticmethod + def Affine(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomAffine( + degrees=params["angle"], + translate=params["shift"][0] / 255.0, + scale=(params["scale"], params["scale"]), + shear=params["shear"], + p=1, + ) + + @staticmethod + def RandomCrop128(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomCrop( + size=(params["height"], params["width"]), + pad_if_needed=True, + p=1, + ) + + @staticmethod + def Elastic(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomElasticTransform( + alpha=(params["alpha"], params["alpha"]), + sigma=(params["sigma"], params["sigma"]), + p=1, ) @staticmethod - def CoarseDropout(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + def Erasing(params: dict[str, Any]) -> Kaug.AugmentationBase2D: return Kaug.RandomErasing( - p=params["p"], + p=1, + scale=params["scale"], + ratio=params["ratio"], + value=params["fill"], + ) + + @staticmethod + def OpticalDistortion(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return kornia.augmentation.RandomFisheye( + center_x=torch.tensor([-0.3, 0.3]), + center_y=torch.tensor([-0.3, 0.3]), + gamma=torch.tensor([0.9, 1.1]), + p=1, + ) + + @staticmethod + def HorizontalFlip(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomHorizontalFlip(p=1) + + @staticmethod + def Perspective(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomPerspective( + distortion_scale=params["scale"][1], + resample=params["interpolation"], + p=1, + ) + + @staticmethod + def RandomResizedCrop(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomResizedCrop( + size=(params["height"], params["width"]), + scale=params["scale"], + ratio=params["ratio"], + p=1, + ) + + @staticmethod + def RandomRotate90(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomRotation90( + times=(0, 3), + p=1, + ) + + @staticmethod + def Rotate(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + # Convert degrees to radians for rotation + angle = torch.tensor(params["angle"]) * (torch.pi / 180.0) + return kornia.geometry.transform.Rotate( + angle=angle, + mode="bilinear", + ) + + @staticmethod + def Shear(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomShear( + shear=params["shear"], + p=1, + ) + + @staticmethod + def ThinPlateSpline(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomThinPlateSpline( + p=1, + ) + + @staticmethod + def VerticalFlip(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomVerticalFlip(p=1) + + @staticmethod + def Resize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.Resize( + size=(params["target_size"], params["target_size"]), + p=1, + ) + + @staticmethod + def Normalize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.Normalize( + mean=params["mean"], + std=params["std"], + p=1, + ) + + @staticmethod + def Posterize(params: dict[str, Any]) -> Kaug.AugmentationBase2D: + return Kaug.RandomPosterize( + bits=params["bits"], + p=1, ) @staticmethod diff --git a/benchmark/transforms/specs.py b/benchmark/transforms/specs.py index c17bacd..a5d7f53 100644 --- a/benchmark/transforms/specs.py +++ b/benchmark/transforms/specs.py @@ -17,91 +17,89 @@ def __str__(self) -> str: # Define all transform specifications based on the original implementations TRANSFORM_SPECS = [ TransformSpec( - "HorizontalFlip", + "Resize", { - "p": 1.0, + "target_size": 512, + "interpolation": "bilinear", }, ), TransformSpec( - "VerticalFlip", + "RandomCrop128", { - "p": 1.0, + "height": 128, + "width": 128, }, ), TransformSpec( - "Rotate", + "RandomResizedCrop", { - "angle": 45, - "p": 1.0, - "interpolation": "nearest", - "mode": "reflect", # from imgaug implementation + "height": 512, + "width": 512, + "scale": (0.08, 1.0), + "ratio": (0.75, 1.3333333333333333), + "interpolation": "bilinear", }, ), TransformSpec( - "Affine", + "CenterCrop128", { - "angle": 25.0, - "shift": (50, 50), - "scale": 2.0, - "shear": [10.0, 15.0], - "p": 1.0, - "interpolation": "bilinear", - "mode": "reflect", # from imgaug implementation + "height": 128, + "width": 128, }, ), TransformSpec( - "Equalize", - { - "p": 1.0, - }, + "HorizontalFlip", + {}, ), TransformSpec( - "RandomCrop80", - { - "height": 80, - "width": 80, - "p": 1.0, - }, + "VerticalFlip", + {}, ), TransformSpec( - "RandomResizedCrop", + "Pad", { - "height": 512, - "width": 512, - "scale": (0.08, 1.0), - "ratio": (0.75, 1.3333333333333333), - "interpolation": "bilinear", - "p": 1.0, + "padding": 10, + "fill": 0, + "border_mode": "constant", }, ), TransformSpec( - "ShiftRGB", + "Rotate", { - "pixel_shift": 100, - "p": 1.0, - "per_channel": True, # from imgaug implementation + "angle": 45, + "interpolation": "nearest", + "mode": "constant", + "fill": 0, }, ), TransformSpec( - "Resize", + "Affine", { - "target_size": 512, + "angle": 25.0, + "shift": (20, 20), + "scale": 2.0, + "shear": (10.0, 15.0), "interpolation": "bilinear", - "p": 1.0, + "mode": "constant", + "fill": 0, }, ), TransformSpec( - "RandomGamma", + "Perspective", { - "gamma": 120, - "p": 1.0, + "scale": (0.05, 0.1), + "interpolation": "bilinear", + "fill": 0, }, ), TransformSpec( - "Grayscale", + "Elastic", { - "p": 1.0, - "num_output_channels": 3, # from torchvision implementation + "alpha": 50.0, + "sigma": 5.0, + "interpolation": "bilinear", + "approximate": False, + "same_dxdy": True, }, ), TransformSpec( @@ -111,22 +109,22 @@ def __str__(self) -> str: "contrast": 1.5, "saturation": 1.5, "hue": 0.5, - "p": 1.0, }, ), TransformSpec( - "PlankianJitter", + "ChannelShuffle", + {}, + ), + TransformSpec( + "Grayscale", { - "mode": "blackbody", - "p": 1.0, + "num_output_channels": 1, }, ), TransformSpec( - "RandomPerspective", + "RGBShift", { - "scale": (0.05, 0.1), - "p": 1.0, - "interpolation": "bilinear", + "pixel_shift": 100, }, ), TransformSpec( @@ -134,112 +132,224 @@ def __str__(self) -> str: { "sigma": 2.0, "kernel_size": (5, 5), - "p": 1.0, }, ), TransformSpec( - "MedianBlur", + "GaussianNoise", { - "blur_limit": 5, - "p": 1.0, + "mean": 0, + "std": 0.44, + "per_channel": True, }, ), TransformSpec( - "MotionBlur", - { - "kernel_size": 5, - "angle": 45, - "direction": 0.0, - "p": 1.0, - }, + "Invert", + {}, ), TransformSpec( "Posterize", { "bits": 4, - "p": 1.0, + }, + ), + TransformSpec( + "Solarize", + { + "threshold": 0.5, + }, + ), + TransformSpec( + "Sharpen", + { + "alpha": (0.2, 0.5), + "lightness": (0.5, 1), + }, + ), + TransformSpec( + "AutoContrast", + {}, + ), + TransformSpec( + "Equalize", + {}, + ), + TransformSpec( + "Normalize", + { + "mean": (0.485, 0.456, 0.406), + "std": (0.229, 0.224, 0.225), + }, + ), + TransformSpec( + "Erasing", + { + "scale": (0.02, 0.33), + "ratio": (0.3, 3.3), + "fill": 0, }, ), TransformSpec( "JpegCompression", { "quality": 50, - "p": 1.0, }, ), TransformSpec( - "GaussianNoise", + "RandomGamma", { - "mean": 127, - "var": 0.010, - "per_channel": True, - "p": 1.0, + "gamma": 120, }, ), TransformSpec( - "Elastic", + "PlankianJitter", { - "alpha": 50.0, - "sigma": 5.0, - "interpolation": "bilinear", - "approximate": False, - "same_dxdy": True, - "p": 1.0, + "mode": "blackbody", }, ), TransformSpec( - "Normalize", + "MedianBlur", { - "mean": (0.485, 0.456, 0.406), - "std": (0.229, 0.224, 0.225), - "p": 1.0, + "blur_limit": 5, }, ), TransformSpec( - "Clahe", + "MotionBlur", + { + "kernel_size": 5, + "angle_range": (0, 360), + "direction_range": (-1, 1), + }, + ), + TransformSpec( + "CLAHE", { "clip_limit": (1, 4), "tile_grid_size": (8, 8), - "p": 1.0, }, ), TransformSpec( "Brightness", { "brightness_limit": (0.2, 0.2), - "p": 1.0, }, ), TransformSpec( "Contrast", { "contrast_limit": (0.2, 0.2), - "p": 1.0, }, ), TransformSpec( "CoarseDropout", { - "hole_height_range": (16, 16), - "hole_width_range": (16, 16), - "num_holes_range": (1, 1), - "p": 1.0, + "hole_height_range": (0.1, 0.1), + "hole_width_range": (0.1, 0.1), + "num_holes_range": (4, 4), }, ), TransformSpec( "Blur", { "radius": 5, - "p": 1.0, + "border_mode": "constant", }, ), TransformSpec( "HSV", { - "hue": 0.015, # standard HSV adjustment values + "hue": 0.015, "saturation": 0.7, "value": 0.4, - "p": 1.0, + }, + ), + TransformSpec( + "ChannelDropout", + {}, + ), + TransformSpec( + "LinearIllumination", + { + "gain": (0.01, 0.2), + }, + ), + TransformSpec( + "CornerIllumination", + { + "gain": (0.01, 0.2), + }, + ), + TransformSpec( + "GaussianIllumination", + { + "gain": (0.01, 0.2), + }, + ), + TransformSpec( + "Hue", + { + "hue": 20, + }, + ), + TransformSpec( + "PlasmaBrightness", + { + "roughness": 0.5, + }, + ), + TransformSpec( + "PlasmaContrast", + { + "roughness": 0.5, + }, + ), + TransformSpec( + "PlasmaShadow", + { + "roughness": 0.5, + }, + ), + TransformSpec( + "Rain", + { + "drop_width": 5, + "drop_height": 20, + "brightness_coefficient": 1.0, + }, + ), + TransformSpec( + "SaltAndPepper", + { + "amount": (0.01, 0.06), + "salt_vs_pepper": (0.4, 0.6), + }, + ), + TransformSpec( + "Saturation", + { + "saturation_factor": 0.5, + }, + ), + TransformSpec( + "Snow", + {"snow_point_range": (0.5, 0.5)}, + ), + TransformSpec( + "OpticalDistortion", + { + "distort_limit": 0.5, + }, + ), + TransformSpec( + "Shear", + { + "shear": 10, + }, + ), + TransformSpec( + "ThinPlateSpline", + { + "num_control_points": 2, + "distortion_scale": 0.5, }, ), ] diff --git a/benchmark/transforms/torchvision_impl.py b/benchmark/transforms/torchvision_impl.py index b7269f6..bc5408e 100644 --- a/benchmark/transforms/torchvision_impl.py +++ b/benchmark/transforms/torchvision_impl.py @@ -9,6 +9,35 @@ class TorchvisionImpl: """Torchvision implementations of transforms""" + @staticmethod + def Resize(params: dict[str, Any]) -> v2.Transform: + return v2.Resize( + size=params["target_size"], + interpolation=InterpolationMode.BILINEAR + if params["interpolation"] == "bilinear" + else InterpolationMode.NEAREST, + antialias=True, + ) + + @staticmethod + def RandomCrop128(params: dict[str, Any]) -> v2.Transform: + return v2.RandomCrop(size=(params["height"], params["width"]), pad_if_needed=True) + + @staticmethod + def RandomResizedCrop(params: dict[str, Any]) -> v2.Transform: + return v2.RandomResizedCrop( + size=(params["height"], params["width"]), + scale=params["scale"], + ratio=params["ratio"], + interpolation=InterpolationMode.BILINEAR + if params["interpolation"] == "bilinear" + else InterpolationMode.NEAREST, + ) + + @staticmethod + def CenterCrop128(params: dict[str, Any]) -> v2.Transform: + return v2.CenterCrop(size=(params["height"], params["width"]), pad_if_needed=True) + @staticmethod def HorizontalFlip(params: dict[str, Any]) -> v2.Transform: return v2.RandomHorizontalFlip(**params) @@ -17,6 +46,10 @@ def HorizontalFlip(params: dict[str, Any]) -> v2.Transform: def VerticalFlip(params: dict[str, Any]) -> v2.Transform: return v2.RandomVerticalFlip(**params) + @staticmethod + def Pad(params: dict[str, Any]) -> v2.Transform: + return v2.Pad(padding=params["padding"], fill=params["fill"], padding_mode=params["border_mode"]) + @staticmethod def Rotate(params: dict[str, Any]) -> v2.Transform: return v2.RandomRotation( @@ -24,6 +57,7 @@ def Rotate(params: dict[str, Any]) -> v2.Transform: interpolation=InterpolationMode.BILINEAR if params["interpolation"] == "bilinear" else InterpolationMode.NEAREST, + fill=params["fill"], ) @staticmethod @@ -39,38 +73,24 @@ def Affine(params: dict[str, Any]) -> v2.Transform: ) @staticmethod - def Equalize(params: dict[str, Any]) -> v2.Transform: - return v2.RandomEqualize(**params) - - @staticmethod - def RandomCrop80(params: dict[str, Any]) -> v2.Transform: - return v2.RandomCrop(size=(params["height"], params["width"])) - - @staticmethod - def RandomResizedCrop(params: dict[str, Any]) -> v2.Transform: - return v2.RandomResizedCrop( - size=(params["height"], params["width"]), - scale=params["scale"], - ratio=params["ratio"], + def Perspective(params: dict[str, Any]) -> v2.Transform: + return v2.RandomPerspective( + distortion_scale=params["scale"][1], # Using max scale interpolation=InterpolationMode.BILINEAR if params["interpolation"] == "bilinear" else InterpolationMode.NEAREST, + fill=params["fill"], + p=1, ) @staticmethod - def Resize(params: dict[str, Any]) -> v2.Transform: - return v2.Resize( - size=params["target_size"], + def Elastic(params: dict[str, Any]) -> v2.Transform: + return v2.ElasticTransform( + alpha=params["alpha"], + sigma=params["sigma"], interpolation=InterpolationMode.BILINEAR if params["interpolation"] == "bilinear" else InterpolationMode.NEAREST, - antialias=True, - ) - - @staticmethod - def Grayscale(params: dict[str, Any]) -> v2.Transform: - return v2.RandomGrayscale( - p=params["p"], ) @staticmethod @@ -83,32 +103,42 @@ def ColorJitter(params: dict[str, Any]) -> v2.Transform: ) @staticmethod - def RandomPerspective(params: dict[str, Any]) -> v2.Transform: - return v2.RandomPerspective( - distortion_scale=params["scale"][1], # Using max scale - p=params["p"], - interpolation=InterpolationMode.BILINEAR - if params["interpolation"] == "bilinear" - else InterpolationMode.NEAREST, + def ChannelShuffle(params: dict[str, Any]) -> v2.Transform: + return v2.RandomChannelPermutation() + + @staticmethod + def Grayscale(params: dict[str, Any]) -> v2.Transform: + return v2.Grayscale( + num_output_channels=params["num_output_channels"], ) @staticmethod def GaussianBlur(params: dict[str, Any]) -> v2.Transform: return v2.GaussianBlur(kernel_size=params["kernel_size"], sigma=(params["sigma"], params["sigma"])) + @staticmethod + def Invert(params: dict[str, Any]) -> v2.Transform: + return v2.RandomInvert(p=1) + @staticmethod def Posterize(params: dict[str, Any]) -> v2.Transform: - return v2.RandomPosterize(bits=params["bits"], p=params["p"]) + return v2.RandomPosterize(bits=params["bits"], p=1) @staticmethod - def Elastic(params: dict[str, Any]) -> v2.Transform: - return v2.ElasticTransform( - alpha=params["alpha"], - sigma=params["sigma"], - interpolation=InterpolationMode.BILINEAR - if params["interpolation"] == "bilinear" - else InterpolationMode.NEAREST, - ) + def Solarize(params: dict[str, Any]) -> v2.Transform: + return v2.RandomSolarize(threshold=params["threshold"], p=1) + + @staticmethod + def Sharpen(params: dict[str, Any]) -> v2.Transform: + return v2.RandomAdjustSharpness(sharpness_factor=params["lightness"][0], p=1) + + @staticmethod + def AutoContrast(params: dict[str, Any]) -> v2.Transform: + return v2.RandomAutocontrast(p=1) + + @staticmethod + def Equalize(params: dict[str, Any]) -> v2.Transform: + return v2.RandomEqualize(p=1) @staticmethod def Normalize(params: dict[str, Any]) -> v2.Transform: @@ -119,6 +149,19 @@ def Normalize(params: dict[str, Any]) -> v2.Transform: ], ) + @staticmethod + def Erasing(params: dict[str, Any]) -> v2.Transform: + return v2.RandomErasing( + scale=params["scale"], + ratio=params["ratio"], + value=params["fill"], + p=1, + ) + + @staticmethod + def JpegCompression(params: dict[str, Any]) -> v2.Transform: + return v2.JPEG(quality=params["quality"]) + @staticmethod def Brightness(params: dict[str, Any]) -> v2.Transform: return v2.ColorJitter(brightness=params["brightness_limit"], contrast=0.0, saturation=0.0, hue=0.0) @@ -127,10 +170,6 @@ def Brightness(params: dict[str, Any]) -> v2.Transform: def Contrast(params: dict[str, Any]) -> v2.Transform: return v2.ColorJitter(brightness=0.0, contrast=params["contrast_limit"], saturation=0.0, hue=0.0) - @staticmethod - def JpegCompression(params: dict[str, Any]) -> v2.Transform: - return v2.JPEG(quality=params["quality"]) - @staticmethod def __call__(transform: v2.Transform, image: torch.Tensor) -> torch.Tensor: """Apply the transform to the image""" diff --git a/output/albumentations_results.json b/output/albumentations_results.json index 1ccd668..97a8f5d 100644 --- a/output/albumentations_results.json +++ b/output/albumentations_results.json @@ -2,16 +2,16 @@ "metadata": { "system_info": { "python_version": "3.12.7 | packaged by Anaconda, Inc. | (main, Oct 4 2024, 08:22:19) [Clang 14.0.6 ]", - "platform": "macOS-15.0.1-arm64-arm-64bit", + "platform": "macOS-15.1-arm64-arm-64bit", "processor": "arm", - "cpu_count": "10", - "timestamp": "2024-11-02T16:32:47.141362+00:00" + "cpu_count": "16", + "timestamp": "2025-01-30T20:22:09.348864+00:00" }, "library_versions": { - "albumentations": "1.4.21", - "numpy": "2.1.2", + "albumentations": "2.0.2", + "numpy": "2.2.2", "pillow": "not installed", - "opencv-python-headless": "4.10.0.84", + "opencv-python-headless": "4.11.0.86", "torch": "not installed", "opencv-python": "not installed" }, @@ -22,8 +22,8 @@ "pillow": "not installed" }, "benchmark_params": { - "num_images": 1000, - "num_runs": 20, + "num_images": 2000, + "num_runs": 5, "max_warmup_iterations": 1000, "warmup_window": 5, "warmup_threshold": 0.05, @@ -31,1542 +31,1277 @@ } }, "results": { - "HorizontalFlip(p=1.0)": { + "Resize(target_size=512, interpolation=bilinear)": { "supported": true, - "warmup_iterations": 22, + "warmup_iterations": 16, "throughputs": [ - 6191.0368383479, - 8989.17817144948, - 9276.613493562785, - 9176.64818182935, - 8504.79959198037, - 8814.931613681078, - 8997.856294170122, - 9164.740831617348, - 8366.549640894533, - 8602.770303815185, - 8573.75574343702, - 5908.978104345355, - 7628.628177877575, - 8851.49293312135, - 8260.605592434487, - 8506.06558490302, - 8640.447234080848, - 8712.527945417964, - 8443.060911203735, - 8740.249650211324 - ], - "median_throughput": 8621.608768948015, - "std_throughput": 891.4153861608924, + 3553.596075899863, + 3662.321732957875, + 3662.3717494372027, + 3636.26804792736, + 3696.2820487058552 + ], + "median_throughput": 3662.321732957875, + "std_throughput": 53.90382612587518, "times": [ - 0.16152383293956518, - 0.11124487477354705, - 0.1077979588881135, - 0.10897225001826882, - 0.11758066597394645, - 0.11344387498684227, - 0.1111375829204917, - 0.10911383293569088, - 0.11952358414418995, - 0.11624162504449487, - 0.11663499986752868, - 0.16923399991355836, - 0.1310851671732962, - 0.11297529214061797, - 0.1210564998909831, - 0.11756316595710814, - 0.11573474993929267, - 0.11477725021541119, - 0.1184404578525573, - 0.11441320786252618 - ], - "mean_time": 0.11598763372349326, - "std_time": 0.011992328123018233, + 0.5628101667389274, + 0.5461016660556197, + 0.5460942080244422, + 0.5500144581310451, + 0.5410842499695718 + ], + "mean_time": 0.5461016660556197, + "std_time": 0.008037788976649547, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "VerticalFlip(p=1.0)": { + "RandomCrop128(height=128, width=128)": { "supported": true, - "warmup_iterations": 23, + "warmup_iterations": 49, "throughputs": [ - 25450.500523902097, - 15235.686553234325, - 19592.28449323103, - 16463.94286067498, - 17688.327079731087, - 21231.385104191973, - 28214.216390682122, - 28164.18722225359, - 28444.27622199942, - 28213.320841864315, - 22169.180191668605, - 26754.95809434625, - 22563.728273715755, - 25338.853977149254, - 16233.35988947292, - 16985.090081753795, - 16545.77907143256, - 26390.96901660055, - 28418.139470290185, - 28479.88611459973 - ], - "median_throughput": 23951.291125432504, - "std_throughput": 5013.1234416187, + 114589.92119675157, + 113189.92607785038, + 116783.77207114537, + 118381.13287499962, + 117933.79451152535 + ], + "median_throughput": 116783.77207114537, + "std_throughput": 2222.2804980399987, "times": [ - 0.03929195809178054, - 0.06563537498004735, - 0.05104050016961992, - 0.06073879194445908, - 0.05653445888310671, - 0.04710008297115564, - 0.03544312505982816, - 0.035506084095686674, - 0.03515645791776478, - 0.0354442500974983, - 0.04510766710154712, - 0.037376249907538295, - 0.04431891697458923, - 0.03946508397348225, - 0.06160154193639755, - 0.058875166112557054, - 0.06043837498873472, - 0.03789174999110401, - 0.03518879204057157, - 0.03511249995790422 - ], - "mean_time": 0.04175140265979888, - "std_time": 0.008738774636330571, + 0.017453541979193687, + 0.017669416964054108, + 0.017125667072832584, + 0.01689458405598998, + 0.016958667431026697 + ], + "mean_time": 0.017125667072832584, + "std_time": 0.0003258846265789088, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Rotate(angle=45, p=1.0, interpolation=nearest, mode=reflect)": { + "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 1224.659498711691, - 925.5676610460062, - 1028.4793650614777, - 1145.3959948722618, - 1144.689463765791, - 1275.445808616896, - 1222.351677571119, - 1182.0383951088374, - 1188.864029951023, - 1212.4129260847935, - 1105.5954683764269, - 1182.086891718114, - 1099.3165138344302, - 1171.1202908547898, - 1126.95712012375, - 1154.0652039106371, - 1233.1308336781117, - 1261.9378009597665, - 1143.8297798650628, - 1049.619492441156 - ], - "median_throughput": 1162.5927473827135, - "std_throughput": 83.97439082897809, + 4520.655583117836, + 4523.842498330771, + 4520.155370510317, + 4539.538107369352, + 4491.518470892838 + ], + "median_throughput": 4520.655583117836, + "std_throughput": 17.35275982631806, "times": [ - 0.8165535000152886, - 1.0804180419072509, - 0.9723092499189079, - 0.873060500016436, - 0.8735993748996407, - 0.7840395830571651, - 0.8180951671674848, - 0.8459962080232799, - 0.8411390830297023, - 0.8248014999553561, - 0.9044899591244757, - 0.8459614999592304, - 0.909656124887988, - 0.8538832499179989, - 0.8873452078551054, - 0.8665021669585258, - 0.8109439588151872, - 0.7924320828169584, - 0.8742559580132365, - 0.9527262090705335 - ], - "mean_time": 0.8601464289634093, - "std_time": 0.06212861086440763, + 0.4424137081950903, + 0.44210204062983394, + 0.44246266689151525, + 0.44057345762848854, + 0.44528370816260576 + ], + "mean_time": 0.4424137081950903, + "std_time": 0.0016982268790504433, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Affine(angle=25.0, shift=(50, 50), scale=2.0, shear=[10.0, 15.0], p=1.0, interpolation=bilinear, mode=reflect)": { + "CenterCrop128(height=128, width=128)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 767.8801371793144, - 954.1601583265846, - 959.8633541801396, - 879.1481231602052, - 865.7219134553635, - 871.5048211066207, - 853.066357729375, - 916.779249100759, - 890.5174798411235, - 914.1291460276772, - 922.067614219473, - 855.9323547670981, - 935.5347190950275, - 973.5721011183113, - 939.6571736845588, - 908.8733644922522, - 904.2349276012876, - 942.9924157398925, - 889.3428158634232, - 833.122102166982 - ], - "median_throughput": 906.5541460467699, - "std_throughput": 49.392463173731926, + 119630.04082214735, + 113651.69995130008, + 118396.02993449329, + 121280.11146898978, + 122754.30214948278 + ], + "median_throughput": 119630.04082214735, + "std_throughput": 3484.189156970239, "times": [ - 1.3022865829989314, - 1.048042083159089, - 1.041814957978204, - 1.137464749859646, - 1.1551053340081125, - 1.1474405829794705, - 1.17224174994044, - 1.0907751249615103, - 1.1229425841011107, - 1.0939373329747468, - 1.084519166033715, - 1.168316625058651, - 1.0689074168913066, - 1.027145291911438, - 1.0642179169226438, - 1.1002632919698954, - 1.1059072918724269, - 1.0604539159685373, - 1.1244257919024676, - 1.2003042500000447 - ], - "mean_time": 1.1030780724579126, - "std_time": 0.060099822287744284, + 0.01671820878982544, + 0.0175976250320673, + 0.01689245831221342, + 0.016490750014781952, + 0.01629270799458027 + ], + "mean_time": 0.01671820878982544, + "std_time": 0.0004869128304994318, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Equalize(p=1.0)": { + "HorizontalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 656.1069890598561, - 894.444682417597, - 943.3949287652506, - 829.5352425719353, - 890.8705476203851, - 958.7345474785478, - 972.6955838735715, - 936.1477412648642, - 753.3556584583569, - 781.4194349413702, - 788.5526076882933, - 705.3965423196645, - 837.4617287483161, - 940.8948291052218, - 811.652269698058, - 782.7063898166542, - 919.9808690588578, - 943.3711958703406, - 867.2434558285287, - 799.7756361058232 - ], - "median_throughput": 852.3525922884223, - "std_throughput": 90.10339032498943, + 12245.578970193195, + 12531.949993153039, + 12873.012258021381, + 12741.663571857667, + 12648.687919376773 + ], + "median_throughput": 12648.687919376773, + "std_throughput": 238.16244515405927, "times": [ - 1.52414166694507, - 1.1180121249053627, - 1.06000145804137, - 1.2054942920804024, - 1.1224975420627743, - 1.0430415829177946, - 1.0280708749778569, - 1.0682074590586126, - 1.3273942908272147, - 1.2797224579844624, - 1.2681462089531124, - 1.4176423330791295, - 1.194084416842088, - 1.0628180420026183, - 1.2320547078270465, - 1.2776182908564806, - 1.0869791249278933, - 1.0600281250663102, - 1.1530787500087172, - 1.250350666930899 - ], - "mean_time": 1.1732233925811961, - "std_time": 0.12402309353730552, + 0.16332424990832806, + 0.15959208272397518, + 0.15536379208788276, + 0.15696537494659424, + 0.158119167201221 + ], + "mean_time": 0.158119167201221, + "std_time": 0.0029772295534841384, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomCrop80(height=80, width=80, p=1.0)": { + "VerticalFlip()": { "supported": true, - "warmup_iterations": 17, + "warmup_iterations": 16, + "throughputs": [ + 24590.856960445824, + 24989.210315740933, + 25608.08543862018, + 26850.292575081134, + 24849.27352118374 + ], + "median_throughput": 24989.210315740933, + "std_throughput": 904.2796812443848, + "times": [ + 0.08133104117587209, + 0.08003454189747572, + 0.07810033299028873, + 0.07448708405718207, + 0.08048525033518672 + ], + "mean_time": 0.08003454189747572, + "std_time": 0.0028961943623324864, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Pad(padding=10, fill=0, border_mode=constant)": { + "supported": true, + "warmup_iterations": 16, "throughputs": [ - 111235.74519905329, - 112063.1248691989, - 112244.99503073642, - 112161.06231828366, - 106456.59310282435, - 101694.48442800525, - 107588.10251393101, - 108129.05566664638, - 106197.04392157738, - 105580.35371383996, - 106081.09888901, - 103494.22279764967, - 107940.839424728, - 105434.26053836347, - 110361.57079603495, - 109533.52354482458, - 109873.50804965799, - 101080.29406658393, - 101993.11005767297, - 111828.67934583552 - ], - "median_throughput": 107764.4709693295, - "std_throughput": 3629.5897566970975, + 31866.39463811293, + 32295.395501748768, + 32591.04924142105, + 31337.197252552513, + 31484.61796464257 + ], + "median_throughput": 31866.39463811293, + "std_throughput": 529.9034070556334, "times": [ - 0.008989915950223804, - 0.00892354198731482, - 0.008909083204343915, - 0.0089157500769943, - 0.009393499931320548, - 0.009833374992012978, - 0.009294708026573062, - 0.009248208021745086, - 0.009416457964107394, - 0.00947145908139646, - 0.00942675000987947, - 0.009662375086918473, - 0.009264334104955196, - 0.009484583046287298, - 0.009061125107109547, - 0.009129625046625733, - 0.009101375006139278, - 0.009893125155940652, - 0.009804583853110671, - 0.008942249929532409 - ], - "mean_time": 0.00927949621062592, - "std_time": 0.00031254052555951527, + 0.06276204204186797, + 0.0619283327832818, + 0.0613665422424674, + 0.06382191693410277, + 0.06352308299392462 + ], + "mean_time": 0.06276204204186797, + "std_time": 0.0010436643457612123, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear, p=1.0)": { + "Rotate(angle=45, interpolation=nearest, mode=constant, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 2936.2955968082106, - 2890.364500330233, - 2871.492450945978, - 2863.7806924023803, - 2583.766237589001, - 2924.7509132239948, - 2886.049037121707, - 2886.9398534908205, - 2910.311122854176, - 2915.0071299513343, - 2855.5936966417325, - 2858.361743746511, - 2887.1041172018054, - 2927.4336768747785, - 2869.057644889159, - 2254.834433730578, - 2898.3294954299913, - 2723.1193553886756, - 2871.247177409666, - 2832.148473951181 - ], - "median_throughput": 2878.7707440338427, - "std_throughput": 157.56720678158456, + 2933.797572252752, + 2913.8579802866284, + 3066.210598860769, + 3077.6775013209644, + 3077.7870295382895 + ], + "median_throughput": 3066.210598860769, + "std_throughput": 82.62917141781472, "times": [ - 0.34056516690179706, - 0.3459771249908954, - 0.34825095906853676, - 0.3491887499112636, - 0.3870319169946015, - 0.34190945816226304, - 0.34649445908144116, - 0.3463875420857221, - 0.34360587503761053, - 0.3430523341521621, - 0.3501898751128465, - 0.3498507500626147, - 0.34636783413589, - 0.341596124926582, - 0.3485464998520911, - 0.44349154201336205, - 0.3450263338163495, - 0.3672259161248803, - 0.34828070807270706, - 0.35308883315883577 - ], - "mean_time": 0.34737048862694847, - "std_time": 0.019013044968842093, + 0.6817102921195328, + 0.6863752501085401, + 0.6522709173150361, + 0.6498406669124961, + 0.6498175412416458 + ], + "mean_time": 0.6522709173150361, + "std_time": 0.017577594134500843, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ShiftRGB(pixel_shift=100, p=1.0, per_channel=True)": { + "Affine(angle=25.0, shift=(20, 20), scale=2.0, shear=(10.0, 15.0), interpolation=bilinear, mode=constant, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 2436.4205865878403, - 2436.7389600273973, - 2453.9623829819056, - 1739.2840727063615, - 1863.3329155589097, - 1511.5387087602355, - 2182.226062813524, - 2020.8314053635454, - 2207.9057929607757, - 2262.944323050212, - 2420.849566305415, - 2418.101665636692, - 2408.6542971921954, - 2356.4578429954836, - 2413.214035858645, - 2403.792704913568, - 2373.1070027464257, - 2344.6015229216127, - 1851.0914163349591, - 2346.0016098052433 - ], - "median_throughput": 2351.2297264003637, - "std_throughput": 276.0214017554926, + 1511.8029755855164, + 1503.0497817451337, + 1504.4175810785714, + 1446.6065657048443, + 1464.3438683458826 + ], + "median_throughput": 1503.0497817451337, + "std_throughput": 28.79460390029961, "times": [ - 0.4104381671641022, - 0.41038454114459455, - 0.4075042090844363, - 0.5749492079485208, - 0.5366727500222623, - 0.6615774999372661, - 0.4582476660143584, - 0.4948458329308778, - 0.45291787502355874, - 0.44190216693095863, - 0.41307812510058284, - 0.4135475419461727, - 0.41516958293505013, - 0.42436575004830956, - 0.414385125041008, - 0.4160092498641461, - 0.42138849990442395, - 0.4265117079485208, - 0.540221834089607, - 0.4262571670114994 - ], - "mean_time": 0.4253093556838272, - "std_time": 0.04992897257866057, + 1.3229237091727555, + 1.3306279168464243, + 1.3294181250967085, + 1.382545916363597, + 1.3657994158565998 + ], + "mean_time": 1.3306279168464243, + "std_time": 0.025491440316625855, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Resize(target_size=512, interpolation=bilinear, p=1.0)": { + "Perspective(scale=(0.05, 0.1), interpolation=bilinear, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 2339.4549065927768, - 2369.1014700836113, - 1752.099781829852, - 2133.892505731186, - 2232.724297026835, - 2327.0777602433013, - 2395.231812140959, - 2399.251431428603, - 2371.283282185992, - 2384.0492782286365, - 2371.4133206756874, - 2397.686474299354, - 2371.758057604355, - 2385.317421196361, - 2390.9269129416366, - 2172.9726003042747, - 2375.449493981629, - 2152.7275933920337, - 2401.2505696374396, - 2377.6347772882023 - ], - "median_throughput": 2371.5856891400213, - "std_throughput": 156.4515673421889, + 1239.3560939318638, + 1247.4469898230147, + 1221.9113134590411, + 1216.9117572193973, + 1208.6098648953293 + ], + "median_throughput": 1221.9113134590411, + "std_throughput": 16.097361267167592, "times": [ - 0.4274500000756234, - 0.4221009579487145, - 0.5707437500823289, - 0.46862716716714203, - 0.4478833330795169, - 0.4297235000412911, - 0.4174961249809712, - 0.4167966670356691, - 0.4217125838622451, - 0.4194544169586152, - 0.42168945888988674, - 0.4170687079895288, - 0.4216281659901142, - 0.4192314159590751, - 0.418247832916677, - 0.46019908390007913, - 0.4209729579742998, - 0.4645269578322768, - 0.41644966695457697, - 0.42058604187332094 - ], - "mean_time": 0.4216588102125956, - "std_time": 0.02781648668377854, + 1.6137412078678608, + 1.6032745409756899, + 1.6367800002917647, + 1.6435045418329537, + 1.6547937081195414 + ], + "mean_time": 1.6367800002917647, + "std_time": 0.021562807946334972, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomGamma(gamma=120, p=1.0)": { + "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True)": { "supported": true, - "warmup_iterations": 19, + "warmup_iterations": 21, "throughputs": [ - 9026.102415510788, - 8879.815071677473, - 9120.918319481852, - 9244.326426870657, - 8988.285989347596, - 8794.401147154107, - 8646.473815105182, - 8518.138456875884, - 9049.917080425213, - 9001.247817172924, - 9101.914130798981, - 9078.60823846364, - 7497.551583006516, - 9037.931041862346, - 8794.085379511449, - 8891.523381643628, - 9040.69214735793, - 9059.106114382765, - 9130.766219236935, - 8807.184368019894 - ], - "median_throughput": 9013.675116341856, - "std_throughput": 371.2021271942723, + 358.5406133174547, + 358.22902934816824, + 372.057461475605, + 356.6500378556215, + 366.0063238600809 + ], + "median_throughput": 358.5406133174547, + "std_throughput": 6.549288107077513, "times": [ - 0.11078979098238051, - 0.11261495784856379, - 0.10963808302767575, - 0.10817445791326463, - 0.11125591699965298, - 0.1137087089009583, - 0.11565408296883106, - 0.11739654210396111, - 0.11049824999645352, - 0.1110957080963999, - 0.10986700002104044, - 0.11014904198236763, - 0.13337687496095896, - 0.11064479197375476, - 0.11371279181912541, - 0.11246666708029807, - 0.11061100009828806, - 0.11038616695441306, - 0.1095198339316994, - 0.11354366596788168 - ], - "mean_time": 0.11094253865296222, - "std_time": 0.004568847424914273, + 5.57816862501204, + 5.583020459394902, + 5.375513750128448, + 5.6077380841597915, + 5.464386458974332 + ], + "mean_time": 5.57816862501204, + "std_time": 0.1018937104419957, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Grayscale(p=1.0, num_output_channels=3)": { + "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 11322.153937061083, - 11433.286257383686, - 11398.62561093383, - 11590.540963864905, - 11018.312431037859, - 12550.305876367664, - 11977.09974476899, - 11346.584266818469, - 11033.605192902682, - 11293.28332946681, - 11527.676518125836, - 11668.702110429487, - 10998.972542170985, - 11106.812411256831, - 10553.013043304023, - 9717.626093612604, - 12104.18071862603, - 12022.969875495979, - 10525.826393701587, - 14364.677311271269 - ], - "median_throughput": 11372.60493887615, - "std_throughput": 923.1985673139618, + 967.8612594198834, + 1038.6202053545278, + 951.5190346312303, + 924.9313751900758, + 1038.700801408656 + ], + "median_throughput": 967.8612594198834, + "std_throughput": 51.912392251918206, "times": [ - 0.0883224168792367, - 0.08746391697786748, - 0.08772987499833107, - 0.08627724996767938, - 0.09075800003483891, - 0.0796793329063803, - 0.0834926669485867, - 0.08813224988989532, - 0.09063220792450011, - 0.08854820788837969, - 0.08674774994142354, - 0.0856993340421468, - 0.09091758308932185, - 0.09003483294509351, - 0.094759666826576, - 0.10290579102002084, - 0.08261608309112489, - 0.08317412505857646, - 0.09500441700220108, - 0.06961520807817578 - ], - "mean_time": 0.08793060212454903, - "std_time": 0.007137978180086127, + 2.0664118751883507, + 1.9256317079998553, + 2.10190225020051, + 2.1623225826770067, + 1.9254822921939194 + ], + "mean_time": 2.0664118751883507, + "std_time": 0.11083446390146501, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5, p=1.0)": { + "ChannelShuffle()": { "supported": true, - "warmup_iterations": 28, + "warmup_iterations": 16, "throughputs": [ - 663.7988895851149, - 714.3535778458653, - 674.9499713096541, - 680.8038036762316, - 703.6967330631392, - 725.502435393903, - 717.2677976509062, - 667.6755244487383, - 700.6547676327622, - 683.8418095631827, - 686.6830386345109, - 601.7514276368507, - 644.2492275487069, - 712.0240416133241, - 701.3846209126009, - 721.7261094249191, - 704.9648409198285, - 700.1571678644112, - 720.0095541552897, - 653.4512682074301 - ], - "median_throughput": 700.4059677485867, - "std_throughput": 31.19256783657957, + 8082.329284140838, + 8161.669046094768, + 8260.916925715383, + 7793.6665737099265, + 8175.155457427395 + ], + "median_throughput": 8161.669046094768, + "std_throughput": 179.83335845494875, "times": [ - 1.5064803748391569, - 1.3998670000582933, - 1.4815912919584662, - 1.46885195793584, - 1.4210667081642896, - 1.37835512496531, - 1.3941794170532376, - 1.497733499854803, - 1.4272364168427885, - 1.4623265000991523, - 1.4562759581021965, - 1.6618157499469817, - 1.5521943329367787, - 1.4044469590298831, - 1.4257512500043958, - 1.3855671659111977, - 1.4185104588977993, - 1.428250749828294, - 1.38887045904994, - 1.5303360000252724 - ], - "mean_time": 1.4277434031786458, - "std_time": 0.06358452812735725, + 0.24745341716334224, + 0.24504791712388396, + 0.24210387514904141, + 0.25661862501874566, + 0.2446436658501625 + ], + "mean_time": 0.24504791712388396, + "std_time": 0.005399360065924721, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "PlankianJitter(mode=blackbody, p=1.0)": { + "Grayscale(num_output_channels=1)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 2385.696321534154, - 2167.6461101731425, - 1850.2139256676992, - 915.4796043205038, - 1830.4205356804118, - 2141.795043576952, - 2082.217754739512, - 2384.2956005911064, - 2256.7808489331637, - 1895.0563574726411, - 1769.1755211040108, - 2467.01016003854, - 2216.8293761794944, - 2233.903880525671, - 2115.202198802671, - 2119.8956461650505, - 2210.465414504765, - 2119.2541391340706, - 2362.3393510036763, - 2360.802649726586 - ], - "median_throughput": 2154.7205768750473, - "std_throughput": 340.194674458262, + 37211.60995822495, + 38248.07909025624, + 38065.51086192335, + 33769.04828434356, + 35866.55848439714 + ], + "median_throughput": 37211.60995822495, + "std_throughput": 1856.4082141821268, "times": [ - 0.4191648329142481, - 0.4613299169577658, - 0.5404780420940369, - 1.0923236249946058, - 0.5463225420098752, - 0.4668980829883367, - 0.4802571670152247, - 0.4194110829848796, - 0.4431090420112014, - 0.527688791975379, - 0.5652350420132279, - 0.40534895891323686, - 0.4510947079397738, - 0.44764683418907225, - 0.4727680410724133, - 0.4717213329859078, - 0.4523934160824865, - 0.47186412499286234, - 0.42330920812673867, - 0.42358474992215633 - ], - "mean_time": 0.4640972990800887, - "std_time": 0.0732732732364235, + 0.05374666675925255, + 0.05229020770639181, + 0.052540999837219715, + 0.05922583257779479, + 0.05576224997639656 + ], + "mean_time": 0.05374666675925255, + "std_time": 0.0026813070912222723, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomPerspective(scale=(0.05, 0.1), p=1.0, interpolation=bilinear)": { + "RGBShift(pixel_shift=100)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 406.3920457344824, - 389.27814442808375, - 372.856714822064, - 327.94901179144915, - 397.8585066781208, - 409.33111888804393, - 403.7411938060417, - 410.69619218262307, - 392.9845382713275, - 405.01472363782136, - 409.7481683836211, - 409.74779080626035, - 403.6042464806563, - 341.9997542631436, - 397.31903690513434, - 389.4007643121203, - 349.48698074924414, - 392.05329533809515, - 405.40725450923156, - 413.1790978151985 - ], - "median_throughput": 400.73137657938855, - "std_throughput": 24.49942924217862, + 3526.388404286177, + 3576.3996081018918, + 3566.368787604189, + 3330.0028704067986, + 3321.677705147184 + ], + "median_throughput": 3526.388404286177, + "std_throughput": 127.68719559749705, "times": [ - 2.4606780828908086, - 2.5688572921790183, - 2.68199541606009, - 3.049254500074312, - 2.5134563751053065, - 2.4430099590681493, - 2.4768342080060393, - 2.4348898748867214, - 2.544629374984652, - 2.4690460411366075, - 2.4405234169680625, - 2.4405256658792496, - 2.4776746248826385, - 2.9239787091501057, - 2.5168690828140825, - 2.568048374960199, - 2.861336916917935, - 2.5506736249662936, - 2.4666554159484804, - 2.420257959049195 - ], - "mean_time": 2.495437239119934, - "std_time": 0.15256301762536092, + 0.5671525001525879, + 0.5592216248624027, + 0.5607944997027516, + 0.6006000828929245, + 0.6021053749136627 + ], + "mean_time": 0.5671525001525879, + "std_time": 0.020536056701119985, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianBlur(sigma=2.0, kernel_size=(5, 5), p=1.0)": { + "GaussianBlur(sigma=2.0, kernel_size=(5, 5))": { "supported": true, - "warmup_iterations": 19, + "warmup_iterations": 16, "throughputs": [ - 1581.4811717902933, - 1610.986822041706, - 1706.7670387803203, - 1773.9675570427287, - 1452.4877621664752, - 1688.8258204218762, - 1655.0571306353681, - 1779.30574146266, - 1775.520631859384, - 1369.487655901637, - 1826.9076540371555, - 1718.6828433320832, - 1639.8296032028584, - 1650.1780628303793, - 1263.633220422084, - 1587.0191360850963, - 1590.7967095338445, - 1692.5267116304017, - 1672.214354719308, - 1800.3061429026764 - ], - "median_throughput": 1663.635742677338, - "std_throughput": 143.80741050581113, + 946.5295964602162, + 945.7227450910851, + 921.0377809407206, + 936.5579907659577, + 942.7464207067845 + ], + "median_throughput": 942.7464207067845, + "std_throughput": 10.528215207111163, "times": [ - 0.6323186249937862, - 0.6207375419326127, - 0.5859030419960618, - 0.5637081670574844, - 0.6884739589877427, - 0.5921273750718683, - 0.6042087499517947, - 0.5620169579051435, - 0.5632150829769671, - 0.7302000829949975, - 0.5473730419762433, - 0.5818409160710871, - 0.6098194580990821, - 0.6059952089563012, - 0.7913688749540597, - 0.6301121248397976, - 0.6286158338189125, - 0.5908326250500977, - 0.5980094580445439, - 0.555461083073169 - ], - "mean_time": 0.6010931205353106, - "std_time": 0.05195947821962958, + 2.1129820002242923, + 2.11478470871225, + 2.1714635831303895, + 2.135479083750397, + 2.1214612498879433 + ], + "mean_time": 2.1214612498879433, + "std_time": 0.023691631282590733, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "MedianBlur(blur_limit=5, p=1.0)": { + "GaussianNoise(mean=0, std=0.44, per_channel=True)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 807.2352221043649, - 768.5568041045487, - 800.6510094274117, - 799.5237774503358, - 743.0480424750505, - 851.5122019129403, - 791.0758467880139, - 813.768198783057, - 805.6304981239407, - 858.8037530579253, - 852.1621216627169, - 857.9551872278904, - 843.2366802410377, - 858.6657312199663, - 865.9857780570901, - 862.7287483965443, - 864.6059818376751, - 862.94136052356, - 831.3057557689207, - 851.6710233953651 - ], - "median_throughput": 847.374441076989, - "std_throughput": 36.051832746824125, + 237.18882853164928, + 228.38826228505314, + 233.82363062471833, + 245.78720349523212, + 228.4101644706014 + ], + "median_throughput": 233.82363062471833, + "std_throughput": 7.23336905856073, "times": [ - 1.2387962921056896, - 1.3011399998795241, - 1.248983624856919, - 1.2507445409428328, - 1.3458080000709742, - 1.1743812921922654, - 1.2641012920066714, - 1.228851166088134, - 1.2412638328969479, - 1.1644103748258203, - 1.1734856250695884, - 1.1655620420351624, - 1.1859066658653319, - 1.1645975420251489, - 1.154753375099972, - 1.159112875116989, - 1.1565962079912424, - 1.1588272920344025, - 1.2029268329497427, - 1.1741622909903526 - ], - "mean_time": 1.1801158396151625, - "std_time": 0.05020842830426871, + 8.43210033280775, + 8.757017457857728, + 8.55345541704446, + 8.13712012488395, + 8.756177749950439 + ], + "mean_time": 8.55345541704446, + "std_time": 0.2646024253071688, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "MotionBlur(kernel_size=5, angle=45, direction=0.0, p=1.0)": { + "Invert()": { "supported": true, - "warmup_iterations": 18, + "warmup_iterations": 16, "throughputs": [ - 3924.1468855928247, - 4001.968968816861, - 3976.8197697547525, - 4071.3642231387694, - 4131.256205131547, - 4067.3926312271715, - 4006.5928478916685, - 4005.533643497983, - 4051.217517426638, - 2707.1118193720313, - 3846.862790987829, - 3878.8474436257206, - 3927.9226180219343, - 3761.0221400081723, - 1549.3797986553895, - 3594.4512364328516, - 1931.9345644237399, - 2878.893240928294, - 3927.539517283191, - 3955.406745543456 - ], - "median_throughput": 3927.7310676525626, - "std_throughput": 742.4529084220972, + 69454.69412356419, + 59691.024065199825, + 35494.006124105596, + 34905.56251315267, + 31485.609284570623 + ], + "median_throughput": 35494.006124105596, + "std_throughput": 17186.362728452077, "times": [ - 0.2548324589151889, - 0.2498769999947399, - 0.25145720900036395, - 0.24561791704036295, - 0.24205712508410215, - 0.24585774983279407, - 0.2495886250399053, - 0.24965462507680058, - 0.24683937500230968, - 0.36939737503416836, - 0.2599520841613412, - 0.2578085409477353, - 0.2545875001233071, - 0.2658851670566946, - 0.6454195419792086, - 0.27820658404380083, - 0.5176158749964088, - 0.34735570801422, - 0.2546123331412673, - 0.252818499924615 - ], - "mean_time": 0.2545999160267501, - "std_time": 0.04812662702262265, + 0.028795749880373478, + 0.033505875151604414, + 0.056347541976720095, + 0.057297457940876484, + 0.06352108297869563 + ], + "mean_time": 0.05634754197672009, + "std_time": 0.02728374170789643, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Posterize(bits=4, p=1.0)": { + "Posterize(bits=4)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 8920.39103080024, - 9310.029855639745, - 9146.442553735083, - 9375.164855998586, - 8458.743006801598, - 8900.409960148925, - 9640.962450670417, - 8832.901405278835, - 8846.28259361947, - 8889.418938240959, - 8692.269761746493, - 9144.097321221934, - 9462.72608549812, - 8633.745740455333, - 9067.11819950243, - 8385.079191828863, - 9000.630065667043, - 9261.199381459297, - 9232.981586087146, - 9287.778337401018 - ], - "median_throughput": 9033.874132584737, - "std_throughput": 331.01824138927736, + 12949.642590158088, + 13217.081795492102, + 15256.475655960452, + 16225.216821074422, + 14146.489266693607 + ], + "median_throughput": 14146.489266693607, + "std_throughput": 1380.548267969441, "times": [ - 0.11210270901210606, - 0.10741104115732014, - 0.10933212493546307, - 0.10666479100473225, - 0.1182208750396967, - 0.11235437518917024, - 0.1037240840960294, - 0.11321308300830424, - 0.11304183304309845, - 0.11249329196289182, - 0.1150447498075664, - 0.10936016589403152, - 0.10567779210396111, - 0.11582458298653364, - 0.11028862511739135, - 0.11925945803523064, - 0.11110333306714892, - 0.1079773751553148, - 0.10830737510696054, - 0.10766837489791214 - ], - "mean_time": 0.11069448005624181, - "std_time": 0.004056055196469045, + 0.15444441698491573, + 0.15131933288648725, + 0.13109187502413988, + 0.12326491670683026, + 0.14137783320620656 + ], + "mean_time": 0.14137783320620656, + "std_time": 0.013796986593813693, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "JpegCompression(quality=50, p=1.0)": { + "Solarize(threshold=0.5)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 895.9263231975085, - 909.2034915677435, - 897.6915195626713, - 909.6506203686774, - 893.0054781519034, - 773.4736936388164, - 849.6490137392127, - 795.3665659924866, - 894.7712470316475, - 881.5651721743994, - 915.4797091085687, - 908.5625667717921, - 908.8097977394475, - 913.213097341246, - 906.9298058148959, - 913.501946800198, - 905.0822177194083, - 871.1697795199128, - 916.7299430365374, - 923.3778015625085 - ], - "median_throughput": 906.0060117671521, - "std_throughput": 39.891994836311305, + 11507.322621951876, + 11556.17919875995, + 12920.025351599057, + 14062.497265240912, + 13139.766354329748 + ], + "median_throughput": 12920.025351599057, + "std_throughput": 1096.5017405024514, "times": [ - 1.116163209080696, - 1.099863792071119, - 1.113968415884301, - 1.0993231660686433, - 1.1198139591142535, - 1.292868792079389, - 1.1769565830472857, - 1.2572819159831852, - 1.1176040840800852, - 1.1343460830394179, - 1.0923234999645501, - 1.1006396659649909, - 1.1003402499482036, - 1.0950346670579165, - 1.102621166035533, - 1.0946884169243276, - 1.104871999938041, - 1.1478818750474602, - 1.0908337919972837, - 1.0829803340602666 - ], - "mean_time": 1.103745435474003, - "std_time": 0.048598581731979916, + 0.17380237486213446, + 0.17306758277118206, + 0.15479845786467195, + 0.14222224988043308, + 0.1522097080014646 + ], + "mean_time": 0.15479845786467195, + "std_time": 0.013137495775478535, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianNoise(mean=127, var=0.01, per_channel=True, p=1.0)": { + "Sharpen(alpha=(0.2, 0.5), lightness=(0.5, 1))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 182.42877367707575, - 185.1676542615163, - 186.4234410236641, - 185.8323607311278, - 181.55803390979784, - 186.36642331276965, - 185.18723853628893, - 187.09914884572586, - 184.302947185153, - 179.17153591949776, - 176.46395915057946, - 184.8084099089121, - 179.41048897849328, - 185.82358092459648, - 166.97479198308434, - 183.82435026775715, - 176.38155836006553, - 175.2491237491372, - 180.6536160834147, - 179.41076525179926 - ], - "median_throughput": 183.12656197241645, - "std_throughput": 5.05243991941347, + 2440.4360723928717, + 2425.93923266951, + 2375.014138561294, + 2368.106810517858, + 2354.3597914082297 + ], + "median_throughput": 2375.014138561294, + "std_throughput": 37.98401012552096, "times": [ - 5.481591416988522, - 5.400511250132695, - 5.364132292103022, - 5.381194083020091, - 5.5078807501122355, - 5.365773416822776, - 5.399940124945715, - 5.344759749947116, - 5.425849207909778, - 5.581243666121736, - 5.6668795419391245, - 5.411009166156873, - 5.5738101250026375, - 5.381448334082961, - 5.9889279580675066, - 5.439975708024576, - 5.669526957906783, - 5.70616262499243, - 5.535455208038911, - 5.57380154193379 - ], - "mean_time": 5.4607042759347255, - "std_time": 0.15066017717298802, + 0.819525667000562, + 0.8244229587726295, + 0.842100250069052, + 0.8445565002039075, + 0.8494878341443837 + ], + "mean_time": 0.842100250069052, + "std_time": 0.013467854319681182, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True, p=1.0)": { + "AutoContrast()": { "supported": true, - "warmup_iterations": 19, + "warmup_iterations": 16, + "throughputs": [ + 1534.4768664273545, + 1530.932832144905, + 1526.9498544235453, + 1713.349491963015, + 1763.9827133191286 + ], + "median_throughput": 1534.4768664273545, + "std_throughput": 115.28977387310482, + "times": [ + 1.3033757912926376, + 1.3063930422067642, + 1.3098007077351213, + 1.1673041661269963, + 1.133797958958894 + ], + "mean_time": 1.3033757912926376, + "std_time": 0.09792646832119653, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Equalize()": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1331.8873105139846, + 1327.1772957537648, + 1302.8775570103724, + 1207.7623793566393, + 1204.8663647740614 + ], + "median_throughput": 1302.8775570103724, + "std_throughput": 63.59123774202713, + "times": [ + 1.5016285418532789, + 1.5069576660171151, + 1.5350636667571962, + 1.6559548750519753, + 1.6599351251497865 + ], + "mean_time": 1.5350636667571962, + "std_time": 0.07492384687775203, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))": { + "supported": true, + "warmup_iterations": 16, "throughputs": [ - 228.91659990420868, - 230.3580084588522, - 228.45467517789558, - 233.3873543786942, - 221.92658933103553, - 210.14295421253053, - 218.74146625969482, - 235.44880752092325, - 243.6783787278612, - 243.4752364899938, - 233.1226034633408, - 234.90984891031832, - 201.6365054374185, - 175.4951359412666, - 205.95273956553845, - 215.09418032823564, - 211.93762700878443, - 226.8445431424017, - 242.73050459939998, - 247.4153701430718 - ], - "median_throughput": 228.68563754105213, - "std_throughput": 17.47520349847134, + 1592.6768181564914, + 1594.153389204078, + 2024.654130014656, + 1797.0527661688634, + 1902.9190940476753 + ], + "median_throughput": 1797.0527661688634, + "std_throughput": 190.30122973616997, "times": [ - 4.368403166998178, - 4.341068959096447, - 4.3772358749993145, - 4.284722292097285, - 4.505994540872052, - 4.758665374945849, - 4.571606916142628, - 4.247207749867812, - 4.103769916808233, - 4.10719387489371, - 4.289588333107531, - 4.256952208001167, - 4.959419415798038, - 5.698163625085726, - 4.855482874903828, - 4.6491262500640005, - 4.718369334004819, - 4.408305292017758, - 4.119795332895592, - 4.0417860839515924 - ], - "mean_time": 4.37281506067685, - "std_time": 0.3341523056199391, + 1.2557475422509015, + 1.2545844167470932, + 0.9878230411559343, + 1.112933374941349, + 1.0510168331675231 + ], + "mean_time": 1.112933374941349, + "std_time": 0.11785552091343719, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)": { + "Erasing(scale=(0.02, 0.33), ratio=(0.3, 3.3), fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 1298.5398244460744, - 1287.3323699192222, - 1206.3193031696821, - 1383.1697070238788, - 1372.9234892353402, - 1415.5093106090922, - 1347.3012544507887, - 1392.2207925653581, - 1430.5854885365252, - 1419.5371717661749, - 1329.7471526754177, - 1280.5107032554051, - 1318.824651192704, - 1345.2291951693187, - 1443.4123696693139, - 1358.5103798686887, - 1484.95352263898, - 1318.672190105303, - 1328.8063114143317, - 1350.7674637356556 - ], - "median_throughput": 1349.034359093222, - "std_throughput": 65.00791962377136, + 28031.84859955734, + 23340.94516244196, + 24091.148722283244, + 37385.594062352975, + 25410.7271287308 + ], + "median_throughput": 25410.7271287308, + "std_throughput": 5726.589256121194, "times": [ - 0.7700957499910146, - 0.77680016704835, - 0.8289679170120507, - 0.7229770829435438, - 0.7283727081958205, - 0.7064595001284033, - 0.7422245000489056, - 0.7182768748607486, - 0.6990145000163466, - 0.7044549589045346, - 0.7520226668566465, - 0.7809384157881141, - 0.7582509161438793, - 0.7433677499648184, - 0.6928027090616524, - 0.7361003749538213, - 0.6734217500779778, - 0.7583385829348117, - 0.7525551251601428, - 0.7403198750689626 - ], - "mean_time": 0.7412709641229361, - "std_time": 0.035720723442159104, + 0.07134741730988026, + 0.08568633301183581, + 0.08301804214715958, + 0.053496541921049356, + 0.07870691735297441 + ], + "mean_time": 0.07870691735297441, + "std_time": 0.01773747697232757, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Clahe(clip_limit=(1, 4), tile_grid_size=(8, 8), p=1.0)": { + "JpegCompression(quality=50)": { "supported": true, - "warmup_iterations": 20, + "warmup_iterations": 16, "throughputs": [ - 465.3788031150073, - 474.0241202523972, - 466.22472832073584, - 478.4851735218444, - 464.82091973484563, - 476.05848332487324, - 465.192675197861, - 471.4698561698571, - 479.79551111982113, - 439.86522750843255, - 466.9416864046196, - 475.6579375220471, - 473.2696884776294, - 470.69844322272377, - 476.7420781159498, - 471.48932525181186, - 479.29122428453314, - 473.29015593778877, - 461.4112806139873, - 398.20049879267253 - ], - "median_throughput": 471.4795907108345, - "std_throughput": 18.33313260054542, + 1364.45926435335, + 1353.8698466203641, + 1348.7235419441608, + 1330.9205960754896, + 1392.069299937516 + ], + "median_throughput": 1353.8698466203641, + "std_throughput": 22.576779498216926, "times": [ - 2.148787167156115, - 2.1095972910989076, - 2.1448883751872927, - 2.089928915956989, - 2.1513661660719663, - 2.100582249928266, - 2.1496469168923795, - 2.121026375098154, - 2.084221250144765, - 2.2734236249234527, - 2.1415950409136713, - 2.1023511248640716, - 2.112960166996345, - 2.1245024588424712, - 2.0975702500436455, - 2.1209387921262532, - 2.08641416602768, - 2.112868791911751, - 2.1672638750169426, - 2.5112977081444114 - ], - "mean_time": 2.12098258270805, - "std_time": 0.08247282745284784, + 1.4657821250148118, + 1.4772468749433756, + 1.4828835842199624, + 1.5027192500419915, + 1.4367100833915174 + ], + "mean_time": 1.4772468749433756, + "std_time": 0.02463418255697266, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Brightness(brightness_limit=(0.2, 0.2), p=1.0)": { + "RandomGamma(gamma=120)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 9262.243083017953, - 8499.519541952239, - 8318.071952067801, - 9086.665195708783, - 9239.134201218676, - 9899.103389085838, - 10842.503157155217, - 9729.397075183238, - 9132.534775718643, - 9201.83300366596, - 10233.328397392555, - 10664.694912203304, - 10626.079822660535, - 9516.290928438746, - 9098.884442003877, - 9528.615483247502, - 9205.563638116262, - 9031.044186889065, - 8944.027179087678, - 10331.52135831708 - ], - "median_throughput": 9250.688642118315, - "std_throughput": 709.1623547430191, + 14493.729534601047, + 12623.118135186754, + 12585.20242080893, + 12630.904243144763, + 14926.07398446572 + ], + "median_throughput": 12630.904243144763, + "std_throughput": 1158.735925172245, "times": [ - 0.10796520789153874, - 0.11765370913781226, - 0.12022016709670424, - 0.11005137511529028, - 0.10823524999432266, - 0.1010192499961704, - 0.09222962497733533, - 0.10278129181824625, - 0.10949862492270768, - 0.10867400001734495, - 0.09771991684101522, - 0.09376733307726681, - 0.09410808281973004, - 0.10508295800536871, - 0.10990358283743262, - 0.10494704102165997, - 0.1086299589369446, - 0.1107291670050472, - 0.1118064580950886, - 0.09679116611368954 - ], - "mean_time": 0.10810006029680942, - "std_time": 0.008287003948972305, + 0.13799070799723268, + 0.158439458347857, + 0.15891679236665368, + 0.15834179101511836, + 0.133993708062917 + ], + "mean_time": 0.15834179101511836, + "std_time": 0.014525984693844269, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Contrast(contrast_limit=(0.2, 0.2), p=1.0)": { + "PlankianJitter(mode=blackbody)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 10585.548513424366, - 10030.136354471706, - 9237.235296404233, - 8862.802703438301, - 7864.579803782532, - 8783.802063008707, - 8789.122582557982, - 9325.364364138219, - 9556.533094353661, - 10812.00398452694, - 10863.321776618523, - 10576.684862536562, - 8361.559384255685, - 8899.136034629908, - 9375.42484231676, - 9055.69134662856, - 6604.478143993113, - 8681.4221796211, - 9390.255494356301, - 8765.413435658631 - ], - "median_throughput": 9146.463321516396, - "std_throughput": 1034.1438188756329, + 3351.387766829782, + 3387.0302311413143, + 3401.558198911732, + 3296.9981230672392, + 3333.8736987347484 + ], + "median_throughput": 3351.387766829782, + "std_throughput": 41.87403839030633, "times": [ - 0.094468415947631, - 0.09969954192638397, - 0.10825749998912215, - 0.112831125035882, - 0.12715237494558096, - 0.1138459169305861, - 0.11377699999138713, - 0.10723441583104432, - 0.10464045801199973, - 0.09248979203402996, - 0.09205287485383451, - 0.09454758395440876, - 0.11959491693414748, - 0.11237045889720321, - 0.10666183312423527, - 0.11042779195122421, - 0.1514124171808362, - 0.11518850014545023, - 0.10649337503127754, - 0.11408474994823337 - ], - "mean_time": 0.10933187668807155, - "std_time": 0.012361596008051014, + 0.5967677091248333, + 0.5904877912253141, + 0.5879658330231905, + 0.6066124169155955, + 0.599902749992907 + ], + "mean_time": 0.5967677091248333, + "std_time": 0.00745633621072343, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "CoarseDropout(hole_height_range=(16, 16), hole_width_range=(16, 16), num_holes_range=(1, 1), p=1.0)": { + "MedianBlur(blur_limit=5)": { "supported": true, - "warmup_iterations": 23, + "warmup_iterations": 16, "throughputs": [ - 12146.111669882064, - 12844.438413310823, - 13921.11375358947, - 14511.20809649814, - 14633.726854110291, - 14465.011438913743, - 14463.582086568676, - 14556.33212776048, - 14059.333891643171, - 14065.719827027859, - 13784.602801091773, - 17817.33228191328, - 18114.24643104558, - 18290.062049987057, - 18307.138798029875, - 18278.5559681027, - 18281.84209822525, - 14536.133902348169, - 12712.56471632674, - 14269.126411249774 - ], - "median_throughput": 14488.10976770594, - "std_throughput": 2107.744661799796, + 1271.7088308512925, + 1257.3428491560242, + 1258.1617010038424, + 1259.3607892615319, + 1274.5535091477543 + ], + "median_throughput": 1259.3607892615319, + "std_throughput": 8.22304634935277, "times": [ - 0.08233087486587465, - 0.0778547078371048, - 0.07183333300054073, - 0.0689122499898076, - 0.06833529216237366, - 0.06913233385421336, - 0.06913916580379009, - 0.06869862484745681, - 0.07112712506204844, - 0.0710948328487575, - 0.07254470908083022, - 0.05612512491643429, - 0.0552051670383662, - 0.05467450013384223, - 0.054623500211164355, - 0.0547089169267565, - 0.054699083091691136, - 0.06879408285021782, - 0.07866233307868242, - 0.07008137507364154 - ], - "mean_time": 0.06902211648264871, - "std_time": 0.010041406359765737, + 1.5726870424114168, + 1.590656042098999, + 1.5896207923069596, + 1.5881072501651943, + 1.5691769593395293 + ], + "mean_time": 1.5881072501651943, + "std_time": 0.01036960943774436, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Blur(radius=5, p=1.0)": { + "MotionBlur(kernel_size=5, angle_range=(0, 360), direction_range=(-1, 1))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 5437.304247327801, - 6080.304103706773, - 6120.475443976756, - 6146.339753965599, - 6101.805560886684, - 6117.7592413594875, - 6128.406961830858, - 6104.5464397113665, - 5760.108731510341, - 5697.91641145246, - 5799.376385000703, - 5694.204172793645, - 5808.956507773419, - 5914.290102401735, - 5894.010944620799, - 5439.58043435473, - 5464.036740325403, - 5701.39105350364, - 5069.780226198483, - 5460.132167020559 - ], - "median_throughput": 5804.16644638706, - "std_throughput": 305.3617565521425, + 3588.208784466163, + 3610.2223446541016, + 3606.3657739239356, + 3638.593102857099, + 3608.055433957421 + ], + "median_throughput": 3608.055433957421, + "std_throughput": 18.09035046352654, "times": [ - 0.18391466699540615, - 0.1644654581323266, - 0.16338599985465407, - 0.1626984579488635, - 0.16388591704890132, - 0.16345854103565216, - 0.16317454213276505, - 0.16381233395077288, - 0.1736078339163214, - 0.1755027500912547, - 0.17243233299814165, - 0.1756171660963446, - 0.1721479578409344, - 0.16908200015313923, - 0.16966375010088086, - 0.18383770808577538, - 0.18301487481221557, - 0.17539579211734235, - 0.19724720902740955, - 0.18314574984833598 - ], - "mean_time": 0.17229002807500007, - "std_time": 0.009064313729691329, + 0.5573811670765281, + 0.553982499986887, + 0.5545749170705676, + 0.5496629998087883, + 0.5543152084574103 + ], + "mean_time": 0.5543152084574103, + "std_time": 0.0027792689363584934, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "HSV(hue=0.015, saturation=0.7, value=0.4, p=1.0)": { + "CLAHE(clip_limit=(1, 4), tile_grid_size=(8, 8))": { + "supported": true, + "warmup_iterations": 22, + "throughputs": [ + 646.6836740929765, + 630.2396301119834, + 653.0860684323634, + 666.9930672436326, + 648.5652027812911 + ], + "median_throughput": 648.5652027812911, + "std_throughput": 13.208783754509591, + "times": [ + 3.0927021666429937, + 3.173396124970168, + 3.0623834999278188, + 2.998531916178763, + 3.0837300419807434 + ], + "mean_time": 3.0837300419807434, + "std_time": 0.06280374449189215, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Brightness(brightness_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 1211.7356599051832, - 1231.3604110622557, - 1234.238073129746, - 1201.559745195675, - 1193.2537014926932, - 1228.0857055349456, - 1237.4928147616367, - 1189.3680010258981, - 1251.133057372916, - 1335.0792469069418, - 1340.4173656156413, - 1220.7040561597491, - 1243.7269524872177, - 1246.253320072416, - 1269.3393770968987, - 1335.3464425483517, - 1266.3398074951174, - 1246.9979833026325, - 1242.059296054026, - 1245.684545287845 - ], - "median_throughput": 1242.8931242706217, - "std_throughput": 43.67190635608972, + 11187.301297885302, + 11429.951181122533, + 11254.393592802668, + 10372.663877781064, + 11276.66935806975 + ], + "median_throughput": 11254.393592802668, + "std_throughput": 418.46999609601517, "times": [ - 0.8252624999731779, - 0.8121099160052836, - 0.8102164580486715, - 0.8322515829931945, - 0.8380447500385344, - 0.8142754170112312, - 0.808085500029847, - 0.8407826670445502, - 0.7992755000013858, - 0.7490192078985274, - 0.7460362911224365, - 0.819199375109747, - 0.8040349998045713, - 0.8024050840176642, - 0.7878113749902695, - 0.7488693331833929, - 0.789677457883954, - 0.8019259159918875, - 0.8051145409699529, - 0.802771459100768 - ], - "mean_time": 0.8045744082676772, - "std_time": 0.0282705709189535, + 0.17877412494271994, + 0.17497887508943677, + 0.17770837526768446, + 0.19281450007110834, + 0.17735733278095722 + ], + "mean_time": 0.17770837526768446, + "std_time": 0.00660769702883458, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Contrast(contrast_limit=(0.2, 0.2))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 11619.870479365214, + 11492.466785855826, + 11196.241416858828, + 11010.224828887947, + 11254.913507479887 + ], + "median_throughput": 11254.913507479887, + "std_throughput": 242.40566858135233, + "times": [ + 0.17211895808577538, + 0.17402704199776053, + 0.1786313750781119, + 0.18164933333173394, + 0.1777001661248505 + ], + "mean_time": 0.1777001661248505, + "std_time": 0.00382726420313086, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "CoarseDropout(hole_height_range=(0.1, 0.1), hole_width_range=(0.1, 0.1), num_holes_range=(4, 4))": { + "supported": true, + "warmup_iterations": 17, + "throughputs": [ + 15759.535731036343, + 15518.79323730862, + 16957.211969602355, + 15863.997955238829, + 15535.901252524387 + ], + "median_throughput": 15759.535731036343, + "std_throughput": 594.3360148043158, + "times": [ + 0.12690729182213545, + 0.1288760001771152, + 0.11794391693547368, + 0.12607162492349744, + 0.12873408291488886 + ], + "mean_time": 0.12690729182213545, + "std_time": 0.004786027669751433, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Blur(radius=5, border_mode=constant)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 7300.944303847169, + 7490.608655933182, + 7403.338996468258, + 7307.851460388761, + 7563.04387162866 + ], + "median_throughput": 7403.338996468258, + "std_throughput": 114.2827330969362, + "times": [ + 0.27393716713413596, + 0.26700099976733327, + 0.2701483750715852, + 0.2736782501451671, + 0.264443791937083 + ], + "mean_time": 0.2701483750715852, + "std_time": 0.004170185190709894, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "HSV(hue=0.015, saturation=0.7, value=0.4)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1228.1173474231578, + 1318.8884276893202, + 1276.8424538628128, + 1308.123362351091, + 1095.1846674745643 + ], + "median_throughput": 1276.8424538628128, + "std_throughput": 91.086124651681, + "times": [ + 1.6285088751465082, + 1.5164284999482334, + 1.5663639581762254, + 1.5289077907800674, + 1.8261760408058763 + ], + "mean_time": 1.5663639581762254, + "std_time": 0.11173972349737471, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "ChannelDropout()": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 10478.59912081127, + 11013.577190029446, + 10811.412220953469, + 10987.853816223893, + 11082.657912440778 + ], + "median_throughput": 10987.853816223893, + "std_throughput": 243.02177412293497, + "times": [ + 0.19086520792916417, + 0.18159404210746288, + 0.18498970894142985, + 0.1820191671140492, + 0.18046212522313 + ], + "mean_time": 0.1820191671140492, + "std_time": 0.004025774428407619, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "LinearIllumination(gain=(0.01, 0.2))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 400.21897316198164, + 496.5128249808623, + 371.99839724547667, + 471.7688275959681, + 461.58283115084447 + ], + "median_throughput": 461.58283115084447, + "std_throughput": 52.14081329622919, + "times": [ + 4.9972643330693245, + 4.028093332890421, + 5.376367249991745, + 4.239364457782358, + 4.332916792016476 + ], + "mean_time": 4.332916792016476, + "std_time": 0.48945019232484527, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "CornerIllumination(gain=(0.01, 0.2))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 426.93552973785916, + 520.8784015786131, + 463.73936412350525, + 440.76883638433475, + 524.2886664328471 + ], + "median_throughput": 463.73936412350525, + "std_throughput": 45.11776041742755, + "times": [ + 4.6845480422489345, + 3.8396677495911717, + 4.31276737479493, + 4.537525875028223, + 3.8146924166940153 + ], + "mean_time": 4.31276737479493, + "std_time": 0.41959432432454347, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "GaussianIllumination(gain=(0.01, 0.2))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 670.2558213789785, + 571.6768356551163, + 752.2538701157132, + 782.9365248346513, + 605.1736598823903 + ], + "median_throughput": 670.2558213789785, + "std_throughput": 91.07923300027198, + "times": [ + 2.983935291878879, + 3.498480041977018, + 2.658676916733384, + 2.554485499858856, + 3.3048364999704063 + ], + "mean_time": 2.983935291878879, + "std_time": 0.40547881724865065, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Hue(hue=20)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1614.387854663288, + 1611.0004470198319, + 1846.2746341396582, + 2020.046691531331, + 1971.7608513328826 + ], + "median_throughput": 1846.2746341396582, + "std_throughput": 193.28132182099841, + "times": [ + 1.2388596669770777, + 1.241464584134519, + 1.083262458909303, + 0.9900761246681213, + 1.0143217919394374 + ], + "mean_time": 1.083262458909303, + "std_time": 0.11340371365423704, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "PlasmaBrightness(roughness=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 163.40645985501476, + 161.0682648586371, + 163.49467357737794, + 163.92722361684105, + 162.61481312974848 + ], + "median_throughput": 163.40645985501476, + "std_throughput": 1.1293677030112492, + "times": [ + 12.239418207667768, + 12.417095333803445, + 12.23281441675499, + 12.200536041986197, + 12.29900254169479 + ], + "mean_time": 12.23941820766777, + "std_time": 0.08459153719903321, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "PlasmaContrast(roughness=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 136.29259385264893, + 137.09988025491322, + 142.31128125259838, + 145.64566301748314, + 138.397894725334 + ], + "median_throughput": 138.397894725334, + "std_throughput": 3.9346238063624197, + "times": [ + 14.674311666283756, + 14.587904790882021, + 14.053699625190347, + 13.731957125011832, + 14.45108687505126 + ], + "mean_time": 14.451086875051258, + "std_time": 0.41084144061029515, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "PlasmaShadow(roughness=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 194.77658462244503, + 191.75460395917287, + 188.19252349327778, + 190.25717878447844, + 189.41825644830024 + ], + "median_throughput": 190.25717878447844, + "std_throughput": 2.534533197231916, + "times": [ + 10.268174708355218, + 10.429997291881591, + 10.62741474993527, + 10.512086917180568, + 10.558644332922995 + ], + "mean_time": 10.512086917180568, + "std_time": 0.14003799191179359, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Rain(drop_width=5, drop_height=20, brightness_coefficient=1.0)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 2121.0547836166597, + 2140.407712670023, + 2149.7223376714774, + 2063.7620799154893, + 1995.9790164432393 + ], + "median_throughput": 2121.0547836166597, + "std_throughput": 64.2512443195918, + "times": [ + 0.9429270830005407, + 0.9344014171510935, + 0.9303527087904513, + 0.9691039579920471, + 1.0020145419985056 + ], + "mean_time": 0.9429270830005407, + "std_time": 0.028563259588290393, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "SaltAndPepper(amount=(0.01, 0.06), salt_vs_pepper=(0.4, 0.6))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 2233.3379376671105, + 2231.9383852810347, + 2185.8643159969165, + 2239.055463603848, + 2283.7188576286144 + ], + "median_throughput": 2233.3379376671105, + "std_throughput": 34.699386845204955, + "times": [ + 0.8955205418169498, + 0.8960820841602981, + 0.9149698750115931, + 0.8932337909936905, + 0.8757645422592759 + ], + "mean_time": 0.8955205418169497, + "std_time": 0.013913708796257241, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Saturation(saturation_factor=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1617.2626071022478, + 1581.1710459212195, + 1566.020947255692, + 1613.6537702072103, + 1313.9116754264924 + ], + "median_throughput": 1581.1710459212195, + "std_throughput": 127.34768118748049, + "times": [ + 1.2366575417108834, + 1.2648852919228375, + 1.277122125029564, + 1.239423249848187, + 1.5221723327413201 + ], + "mean_time": 1.2648852919228375, + "std_time": 0.10187399352526999, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Snow(snow_point_range=(0.5, 0.5))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 575.607861325682, + 630.1422975489292, + 648.8052737492451, + 584.6288575949653, + 587.7905253585991 + ], + "median_throughput": 587.7905253585991, + "std_throughput": 32.114266421412246, + "times": [ + 3.474587708711624, + 3.17388629168272, + 3.0825889999978244, + 3.420973792206496, + 3.40257270867005 + ], + "mean_time": 3.4025727086700495, + "std_time": 0.18590147641082203, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "OpticalDistortion(distort_limit=0.5)": { + "supported": true, + "warmup_iterations": 19, + "throughputs": [ + 709.4726183904862, + 686.5372674334461, + 623.9205686675298, + 647.8548776405804, + 710.4017933942197 + ], + "median_throughput": 686.5372674334461, + "std_throughput": 38.4665158072132, + "times": [ + 2.8189953328110278, + 2.913170333020389, + 3.205536250025034, + 3.087111124768853, + 2.8153082081116736 + ], + "mean_time": 2.913170333020389, + "std_time": 0.16322422391308353, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Shear(shear=10)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1364.130395861408, + 1355.459476973854, + 1335.7458756583628, + 1331.573031020628, + 1321.8152554555581 + ], + "median_throughput": 1335.7458756583628, + "std_throughput": 17.506041740942603, + "times": [ + 1.4661354999989271, + 1.4755144170485437, + 1.4972907919436693, + 1.5019829580560327, + 1.5130707500502467 + ], + "mean_time": 1.4972907919436693, + "std_time": 0.019623219940077062, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "ThinPlateSpline(num_control_points=2, distortion_scale=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 80.58679165079867, + 79.85679919156763, + 69.79150603216426, + 74.95792506502985, + 71.84500926274121 + ], + "median_throughput": 74.95792506502985, + "std_throughput": 4.771115471398106, + "times": [ + 24.81796283274889, + 25.044830499682575, + 28.656782375182956, + 26.681635040789843, + 27.837702583987266 + ], + "mean_time": 26.681635040789846, + "std_time": 1.698301568978463, "variance_stable": true, "early_stopped": false, "early_stop_reason": null diff --git a/output/augly_results.json b/output/augly_results.json index aeac814..440dc75 100644 --- a/output/augly_results.json +++ b/output/augly_results.json @@ -1,16 +1,16 @@ { "metadata": { "system_info": { - "python_version": "3.12.7 | packaged by Anaconda, Inc. | (main, Oct 4 2024, 08:22:19) [Clang 14.0.6 ]", - "platform": "macOS-15.0.1-arm64-arm-64bit", + "python_version": "3.12.8 | packaged by Anaconda, Inc. | (main, Dec 11 2024, 10:37:40) [Clang 14.0.6 ]", + "platform": "macOS-15.1-arm64-arm-64bit", "processor": "arm", - "cpu_count": "10", - "timestamp": "2024-11-02T18:08:28.741550+00:00" + "cpu_count": "16", + "timestamp": "2025-01-23T23:58:28.656651+00:00" }, "library_versions": { "augly": "1.0.0", - "numpy": "2.1.3", - "pillow": "11.0.0", + "numpy": "2.2.2", + "pillow": "11.1.0", "opencv-python-headless": "not installed", "torch": "not installed", "opencv-python": "not installed" @@ -22,8 +22,8 @@ "pillow": "{'threads': 'unknown', 'simd': False}" }, "benchmark_params": { - "num_images": 1000, - "num_runs": 20, + "num_images": 2000, + "num_runs": 5, "max_warmup_iterations": 1000, "warmup_window": 5, "warmup_threshold": 0.05, @@ -31,764 +31,418 @@ } }, "results": { - "HorizontalFlip(p=1.0)": { + "Resize(target_size=512, interpolation=bilinear)": { "supported": true, - "warmup_iterations": 17, + "warmup_iterations": 16, "throughputs": [ - 3241.7275142736635, - 2447.834353994278, - 3941.7689085790753, - 4588.910146525562, - 4299.941713671053, - 2908.0172317779125, - 2988.5270463732772, - 4469.517606307445, - 2759.910233412848, - 5017.293985910462, - 5159.97980972829, - 2495.8407867992337, - 3918.2726685516004, - 3666.236235304671, - 2729.5773617971886, - 4326.416589274426, - 5096.199248560114, - 5369.300488044128, - 5140.6822516239545, - 4900.589508095937 + 1050.16530288884, + 1049.9860510307838, + 1082.5044280722686, + 1087.871679027065, + 1093.8230356231938 ], - "median_throughput": 4120.855311125064, - "std_throughput": 1001.4279081202058, + "median_throughput": 1082.5044280722686, + "std_throughput": 21.190095982696217, "times": [ - 0.3084775002207607, - 0.4085243751760572, - 0.25369320809841156, - 0.2179166660644114, - 0.23256129189394414, - 0.3438769169151783, - 0.3346129998099059, - 0.2237377918791026, - 0.3623306250665337, - 0.19931062497198582, - 0.19379920791834593, - 0.4006665830966085, - 0.25521450000815094, - 0.2727592920418829, - 0.3663570829667151, - 0.2311381669715047, - 0.19622466689907014, - 0.18624399998225272, - 0.1945267089176923, - 0.20405708299949765 + 1.9044620827771723, + 1.9047872093506157, + 1.8475675000809133, + 1.8384521249681711, + 1.8284493330866098 ], - "mean_time": 0.2426680687624004, - "std_time": 0.058971877952675264, + "mean_time": 1.847567500080913, + "std_time": 0.03616625636436747, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "VerticalFlip(p=1.0)": { + "RandomCrop128(height=128, width=128)": { "supported": true, - "warmup_iterations": 20, + "warmup_iterations": 17, "throughputs": [ - 7459.279346779039, - 2961.789944536651, - 5355.779992614105, - 6511.356314098547, - 6940.983977380074, - 6784.747643520724, - 4846.782115601181, - 8159.022074621719, - 8127.977680566088, - 8527.439156392345, - 8065.502656102923, - 7657.444235659582, - 7892.23419263678, - 8131.99304848842, - 7264.034684864436, - 8038.819449628358, - 7925.945235265317, - 7894.059075213587, - 7942.401700703985, - 7623.033382848522 + 45395.178885371504, + 44765.30306763063, + 45504.747706990885, + 45787.93861034798, + 43448.50832548043 ], - "median_throughput": 7774.839214148181, - "std_throughput": 1376.0591057961178, + "median_throughput": 45395.178885371504, + "std_throughput": 934.352639617186, "times": [ - 0.1340612079948187, - 0.33763366704806685, - 0.18671416700817645, - 0.15357783413492143, - 0.14407179201953113, - 0.1473894170485437, - 0.20632245810702443, - 0.1225637081079185, - 0.12303183390758932, - 0.11726850015111268, - 0.12398483301512897, - 0.1305918749421835, - 0.12670683301985264, - 0.12297108396887779, - 0.13766454090364277, - 0.1243963751476258, - 0.126167916925624, - 0.1266775419935584, - 0.12590650003403425, - 0.13118137489072978 + 0.044057541992515326, + 0.0446774591691792, + 0.0439514578320086, + 0.043679625261574984, + 0.0460314997471869 ], - "mean_time": 0.12862002318713686, - "std_time": 0.022764297655480013, + "mean_time": 0.044057541992515326, + "std_time": 0.0009068205405622298, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Rotate(angle=45, p=1.0, interpolation=nearest, mode=reflect)": { + "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear)": { + "supported": false + }, + "CenterCrop128(height=128, width=128)": { + "supported": false + }, + "HorizontalFlip()": { "supported": true, - "warmup_iterations": 18, + "warmup_iterations": 16, "throughputs": [ - 1054.2010901319004, - 970.9313673725524, - 865.349522749395, - 1098.8069156786494, - 1126.0607144689773, - 1112.9027298381525, - 980.1091743136664, - 1074.9493664896847, - 1113.0224177806704, - 1116.191176342393, - 1142.1434127066893, - 1060.0281573116697, - 1091.6621886020762, - 1115.7984463171078, - 1120.2862030806095, - 1133.9253205876755, - 1100.5746869887369, - 862.9818232433488, - 1075.2937731905001, - 1080.9803851157428 + 8808.419076819217, + 10534.412990935896, + 10430.039221544415, + 8496.262432067686, + 8638.537700325796 ], - "median_throughput": 1095.2345521403627, - "std_throughput": 81.99355443772939, + "median_throughput": 8808.419076819217, + "std_throughput": 1011.5215189058365, "times": [ - 0.9485856250394136, - 1.0299389159772545, - 1.1556024169549346, - 0.9100779998116195, - 0.8880515829659998, - 0.8985511250793934, - 1.0202945000492036, - 0.9302763750310987, - 0.8984545001294464, - 0.8959038748871535, - 0.8755467911250889, - 0.9433711671736091, - 0.9160342919640243, - 0.8962192081380635, - 0.8926290418021381, - 0.8818922920618206, - 0.9086162091698498, - 1.1587729579769075, - 0.9299784160684794, - 0.9250861660111696 + 0.22705550026148558, + 0.18985395785421133, + 0.19175383308902383, + 0.2353976252488792, + 0.23152066580951214 ], - "mean_time": 0.9130464319681565, - "std_time": 0.06835423716084629, + "mean_time": 0.22705550026148555, + "std_time": 0.026074091445630724, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Affine(angle=25.0, shift=(50, 50), scale=2.0, shear=[10.0, 15.0], p=1.0, interpolation=bilinear, mode=reflect)": { - "supported": false - }, - "Equalize(p=1.0)": { - "supported": false - }, - "RandomCrop80(height=80, width=80, p=1.0)": { + "VerticalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 25475.272986829692, - 26308.462709782492, - 11394.133933124403, - 6749.706822012376, - 10327.986689891564, - 21511.698927281792, - 24163.90355998447, - 24841.917275947522, - 24281.02844523507, - 27265.105194369655, - 24276.926974131078, - 25585.944915680175, - 26690.74741012952, - 25973.576718949385, - 25512.02107965949, - 24907.99612671042, - 26485.739482112098, - 22455.84640347615, - 25833.924195868327, - 26468.943708731284 + 16829.922650066146, + 15771.896351022997, + 19943.137137215206, + 16380.363057512666, + 18072.05768429302 ], - "median_throughput": 25191.634556770055, - "std_throughput": 5964.147781493371, + "median_throughput": 16829.922650066146, + "std_throughput": 1653.3735077678014, "times": [ - 0.039253750117495656, - 0.038010582793504, - 0.08776445896364748, - 0.14815458306111395, - 0.0968242920935154, - 0.04648633301258087, - 0.04138404200784862, - 0.04025454190559685, - 0.041184416972100735, - 0.03667691699229181, - 0.04119137488305569, - 0.03908395813778043, - 0.037466167006641626, - 0.03850066591985524, - 0.03919720812700689, - 0.04014774993993342, - 0.03775616688653827, - 0.04453183291479945, - 0.03870879206806421, - 0.03778012492693961 + 0.1188359591178596, + 0.12680783309042454, + 0.10028512496501207, + 0.12209741584956646, + 0.11066808411851525 ], - "mean_time": 0.03969571715350474, - "std_time": 0.009398005630096705, + "mean_time": 0.11883595911785962, + "std_time": 0.011674458086405664, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear, p=1.0)": { + "Pad(padding=10, fill=0, border_mode=constant)": { "supported": false }, - "ShiftRGB(pixel_shift=100, p=1.0, per_channel=True)": { - "supported": false - }, - "Resize(target_size=512, interpolation=bilinear, p=1.0)": { + "Rotate(angle=45, interpolation=nearest, mode=constant, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 635.712483602099, - 562.4114024492757, - 631.1280562142102, - 560.9313555107776, - 583.4973811917799, - 631.8223821905177, - 647.0883787351574, - 640.4503646662301, - 548.6261406633939, - 633.783864928797, - 635.363254352138, - 556.415965351621, - 631.6657016567384, - 558.8388111807304, - 632.4853822981329, - 646.7242069751262, - 644.3728519500512, - 643.3501907141231, - 644.7784271638051, - 567.4249293975661 + 1554.7296913344674, + 1582.3085769976494, + 1740.8390427286595, + 1787.9325720526006, + 1738.68266049048 ], - "median_throughput": 632.1538822443254, - "std_throughput": 37.90384998845349, + "median_throughput": 1738.68266049048, + "std_throughput": 104.91271567837464, "times": [ - 1.5730381670873612, - 1.7780578339006752, - 1.5844644999597222, - 1.782749333186075, - 1.7138037499971688, - 1.582723290892318, - 1.545383958145976, - 1.5614012500736862, - 1.822734875138849, - 1.577824957901612, - 1.573902792064473, - 1.7972165830433369, - 1.5831158750224859, - 1.7894247500225902, - 1.581064207945019, - 1.5462541671004146, - 1.5518965409137309, - 1.5543634158093482, - 1.550920374924317, - 1.762347666081041 + 1.2863972503691912, + 1.26397595833987, + 1.1488712918944657, + 1.1186104170046747, + 1.1502961670048535 ], - "mean_time": 1.5818933144090117, - "std_time": 0.09485008092368623, + "mean_time": 1.1502961670048535, + "std_time": 0.06940927028101866, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomGamma(gamma=120, p=1.0)": { + "Affine(angle=25.0, shift=(20, 20), scale=2.0, shear=(10.0, 15.0), interpolation=bilinear, mode=constant, fill=0)": { "supported": false }, - "Grayscale(p=1.0, num_output_channels=3)": { + "Perspective(scale=(0.05, 0.1), interpolation=bilinear, fill=0)": { + "supported": false + }, + "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True)": { + "supported": false + }, + "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 3267.6521620006183, - 3369.7524034031917, - 3371.88806404848, - 3392.753163406204, - 3356.693119753887, - 3472.342283177366, - 3408.308544537698, - 3354.785793030886, - 3401.7365854143645, - 3333.2370342568433, - 3461.1287864214264, - 3361.395846007976, - 3309.2265344636808, - 3389.670594796287, - 3241.8457465137126, - 3338.676149277705, - 3349.9303739943707, - 3248.129925436118, - 3257.3068875910008, - 3395.4478573379774 + 414.24576333610673, + 424.4618571116887, + 412.80352445109884, + 419.7383278254062, + 418.3226141895712 ], - "median_throughput": 3359.0444828809314, - "std_throughput": 64.52743476205183, + "median_throughput": 418.3226141895712, + "std_throughput": 4.635258623118236, "times": [ - 0.30603012512438, - 0.2967577080707997, - 0.2965697499457747, - 0.29474587505683303, - 0.297912250040099, - 0.28799004200845957, - 0.29340066690929234, - 0.2980816247873008, - 0.293967500096187, - 0.30000866716727614, - 0.28892308310605586, - 0.29749545897357166, - 0.3021854169201106, - 0.29501391714438796, - 0.30846624984405935, - 0.29951991606503725, - 0.29851366695947945, - 0.3078694581054151, - 0.3070020831655711, - 0.29451195895671844 + 4.8280517919920385, + 4.711848583072424, + 4.8449198747985065, + 4.764873416163027, + 4.780998999718577 ], - "mean_time": 0.29770370862797746, - "std_time": 0.005718905103762403, + "mean_time": 4.780998999718577, + "std_time": 0.05297625824866935, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5, p=1.0)": { + "ChannelShuffle()": { + "supported": false + }, + "Grayscale(num_output_channels=1)": { "supported": true, - "warmup_iterations": 16, + "warmup_iterations": 21, "throughputs": [ - 252.9440500085872, - 264.118088540553, - 237.92881771104078, - 262.06974206512, - 256.63915057362874, - 213.91957565324768, - 222.26461099091068, - 233.23641456561217, - 229.8020117810596, - 226.23618847846961, - 238.5572818563759, - 259.01613861079915, - 248.14402999045248, - 230.93240893461316, - 259.979897045149, - 261.0878601810458, - 251.52984116405293, - 254.01410823433721, - 251.76300980953778, - 258.8090791991561 + 6057.422865374584, + 6087.9626901404645, + 6276.162933843943, + 6022.44639934216, + 6205.354593139259 ], - "median_throughput": 251.64642548679535, - "std_throughput": 15.201506480691371, + "median_throughput": 6087.9626901404645, + "std_throughput": 106.82250021344477, "times": [ - 3.953443459002301, - 3.786185208009556, - 4.202937708934769, - 3.815778166987002, - 3.8965216248761863, - 4.6746539999730885, - 4.499141791136935, - 4.287495166063309, - 4.351571999955922, - 4.4201593331526965, - 4.191865334054455, - 3.860763292061165, - 4.029917625011876, - 4.330271375132725, - 3.8464512501377612, - 3.8301282920874655, - 3.9756714168470353, - 3.9367892080917954, - 3.9719893750734627, - 3.8638520839158446 + 0.3301734160631895, + 0.3285171249881387, + 0.31866604182869196, + 0.33209095895290375, + 0.3223022907041013 ], - "mean_time": 3.9738295430406305, - "std_time": 0.2400518721251011, + "mean_time": 0.3285171249881387, + "std_time": 0.005764329126227944, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "PlankianJitter(mode=blackbody, p=1.0)": { + "RGBShift(pixel_shift=100)": { "supported": false }, - "RandomPerspective(scale=(0.05, 0.1), p=1.0, interpolation=bilinear)": { - "supported": false - }, - "GaussianBlur(sigma=2.0, kernel_size=(5, 5), p=1.0)": { + "GaussianBlur(sigma=2.0, kernel_size=(5, 5))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 196.752559653053, - 210.34504264202883, - 244.62537168234107, - 243.2928100170488, - 223.13416535608945, - 241.63069792313303, - 228.62408395889264, - 231.94846795293424, - 236.58705432260373, - 208.4081865987477, - 180.40522757216527, - 237.36361893033276, - 229.9423095589955, - 210.26057962019834, - 233.24473789345066, - 238.73219594401615, - 239.46647112074905, - 241.85740196519401, - 238.4033981604823, - 241.89139480399234 + 384.41777910508904, + 386.7694861044822, + 381.51304764292047, + 391.020845001914, + 390.8052512936959 ], - "median_throughput": 234.9158961080272, - "std_throughput": 17.651184506925034, + "median_throughput": 386.7694861044822, + "std_throughput": 4.1057862174494915, "times": [ - 5.082525999983773, - 4.754093500087038, - 4.0878834158647805, - 4.110273542115465, - 4.481608625035733, - 4.1385470000095665, - 4.373992375098169, - 4.311302457936108, - 4.22677395795472, - 4.798276000190526, - 5.543076625093818, - 4.212945541134104, - 4.348916917107999, - 4.756003249902278, - 4.287342166993767, - 4.188794041983783, - 4.175949957920238, - 4.134667749982327, - 4.194571082945913, - 4.134086707839742 + 5.202672999817878, + 5.17103875009343, + 5.242284667212516, + 5.114816832821816, + 5.117638499941677 ], - "mean_time": 4.256842625669509, - "std_time": 0.3198519804214654, + "mean_time": 5.17103875009343, + "std_time": 0.054893626288541914, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "MedianBlur(blur_limit=5, p=1.0)": { + "Invert()": { + "supported": false + }, + "Posterize(bits=4)": { + "supported": false + }, + "Solarize(threshold=0.5)": { + "supported": false + }, + "Sharpen(alpha=(0.2, 0.5), lightness=(0.5, 1))": { + "supported": false + }, + "AutoContrast()": { + "supported": false + }, + "Equalize()": { "supported": false }, - "MotionBlur(kernel_size=5, angle=45, direction=0.0, p=1.0)": { + "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))": { "supported": false }, - "Posterize(bits=4, p=1.0)": { + "Erasing(scale=(0.02, 0.33), ratio=(0.3, 3.3), fill=0)": { "supported": false }, - "JpegCompression(quality=50, p=1.0)": { + "JpegCompression(quality=50)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 759.4699977592936, - 757.2306296942144, - 737.114410831614, - 764.6067850404668, - 753.0550506559146, - 758.932925184639, - 755.7650704004087, - 723.0610720641112, - 752.826297958913, - 756.2226964442727, - 755.2833251672663, - 752.3127740811364, - 746.327648294097, - 715.983340430127, - 758.113640413622, - 753.5395638688225, - 762.3420070480083, - 753.992057893477, - 748.1027417418138, - 722.744078532869 + 1201.8376696245994, + 1224.4720535145607, + 1213.4784694469554, + 1176.566502170569, + 1191.4178003304642 ], - "median_throughput": 753.7658108811497, - "std_throughput": 13.773952444115814, + "median_throughput": 1201.8376696245994, + "std_throughput": 18.672360638219956, "times": [ - 1.3167077079415321, - 1.3206016249023378, - 1.356641500024125, - 1.3078617919236422, - 1.3279241658747196, - 1.3176394999027252, - 1.3231625000480562, - 1.3830090411938727, - 1.3283276669681072, - 1.322361791972071, - 1.3240064578130841, - 1.3292343749199063, - 1.3398940830957144, - 1.3966805420350283, - 1.3190634578932077, - 1.3270703330636024, - 1.31174720893614, - 1.3262739169877023, - 1.3367147909011692, - 1.383615625090897 + 1.6641182503663003, + 1.6333570000715554, + 1.6481544999405742, + 1.6998614156618714, + 1.6786722503602505 ], - "mean_time": 1.3266720055012886, - "std_time": 0.02424296359548707, + "mean_time": 1.6641182503663003, + "std_time": 0.02585458660585085, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianNoise(mean=127, var=0.01, per_channel=True, p=1.0)": { - "supported": true, - "warmup_iterations": 20, - "throughputs": [ - 67.8011792789446, - 68.64781672227694, - 68.82963685730876, - 71.37720342221878, - 71.02533628850576, - 71.98643674804471, - 70.39510838559134, - 70.00159801810064, - 68.62886210731787, - 70.15852998202955, - 71.13338524143973, - 70.31489503071334, - 69.50143743302345, - 67.81451971789608, - 69.28990890326153, - 69.06508110477932, - 68.61157045409217, - 68.34592334694966, - 69.81046824413826, - 70.64910136132018 - ], - "median_throughput": 69.65595283858086, - "std_throughput": 1.2076533615818505, - "times": [ - 14.749006000114605, - 14.567105666967109, - 14.528625250095502, - 14.010075374972075, - 14.079482791014016, - 13.891505749896169, - 14.205532499821857, - 14.285388167016208, - 14.571128957904875, - 14.253434333018959, - 14.058096583001316, - 14.221737792016938, - 14.388191625010222, - 14.746104582911357, - 14.432115957839414, - 14.47909687506035, - 14.574801208917052, - 14.631450582994148, - 14.324499249923974, - 14.15446170908399 - ], - "mean_time": 14.356274794164076, - "std_time": 0.24890052907814417, - "variance_stable": true, - "early_stopped": false, - "early_stop_reason": null + "RandomGamma(gamma=120)": { + "supported": false }, - "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True, p=1.0)": { + "PlankianJitter(mode=blackbody)": { "supported": false }, - "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)": { + "MedianBlur(blur_limit=5)": { "supported": false }, - "Clahe(clip_limit=(1, 4), tile_grid_size=(8, 8), p=1.0)": { + "MotionBlur(kernel_size=5, angle_range=(0, 360), direction_range=(-1, 1))": { "supported": false }, - "Brightness(brightness_limit=(0.2, 0.2), p=1.0)": { + "CLAHE(clip_limit=(1, 4), tile_grid_size=(8, 8))": { + "supported": false + }, + "Brightness(brightness_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 1299.0015165599787, - 1297.4918512133286, - 1293.8389712488533, - 1298.4586809869807, - 1305.0944958798796, - 1298.8557140999667, - 1284.4985546932025, - 1143.8674495886692, - 1305.3892996990257, - 1295.7203004316589, - 1283.7481335968328, - 1252.1084989142894, - 1289.178262816638, - 1301.8530087568586, - 1292.0250660186216, - 1292.0133127177578, - 1301.5689762839859, - 1304.5703113690877, - 1299.0835718926917, - 1188.3335343721235 + 2125.948262993417, + 2083.5362614465307, + 2108.3773603554478, + 2103.5255344652905, + 2168.398458281695 ], - "median_throughput": 1296.6060758224937, - "std_throughput": 41.72055467929612, + "median_throughput": 2108.3773603554478, + "std_throughput": 31.9883765351776, "times": [ - 0.7698220419697464, - 0.770717749837786, - 0.772893707966432, - 0.7701438749209046, - 0.7662280418444425, - 0.7699084579944611, - 0.7785139160696417, - 0.8742271671071649, - 0.7660550000146031, - 0.7717715001199394, - 0.7789690000936389, - 0.7986528330948204, - 0.7756879159715027, - 0.7681358749978244, - 0.7739787921309471, - 0.7739858329296112, - 0.7683035000227392, - 0.766535917064175, - 0.7697734169196337, - 0.8415145841427147 + 0.940756666008383, + 0.9599064998328686, + 0.9485967918299139, + 0.9507847502827644, + 0.9223397076129913 ], - "mean_time": 0.7712442650445367, - "std_time": 0.02481612505978197, + "mean_time": 0.9485967918299139, + "std_time": 0.014392144370209475, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Contrast(contrast_limit=(0.2, 0.2), p=1.0)": { + "Contrast(contrast_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 885.1025516702621, - 879.5878339052148, - 876.6517714994122, - 885.2466560856083, - 877.732197232541, - 875.6465829718582, - 888.3717246890324, - 880.2167975355675, - 886.2027751918422, - 849.8745175850174, - 882.7392368286675, - 873.320114107716, - 879.030045622893, - 887.9338335380628, - 881.5880664187727, - 880.3832775466961, - 879.8433174561546, - 861.3894763931858, - 873.2626622701156, - 875.4916618211894 + 1368.873627555974, + 1325.1797963257934, + 1379.3160522085602, + 1384.2671744712575, + 1383.8236780291913 ], - "median_throughput": 879.7155756806847, - "std_throughput": 9.044965584299083, + "median_throughput": 1379.3160522085602, + "std_throughput": 24.884580291443484, "times": [ - 1.129812582861632, - 1.1368961250409484, - 1.1407037919852883, - 1.1296286669094115, - 1.1392996669746935, - 1.1420132499188185, - 1.1256549169775099, - 1.1360837498214096, - 1.1284099170006812, - 1.1766442919615656, - 1.1328373751603067, - 1.1450555000919849, - 1.137617542175576, - 1.1262100420426577, - 1.1343166248407215, - 1.1358689169865102, - 1.136566000059247, - 1.160915041808039, - 1.145130833145231, - 1.1422153329476714 + 1.4610552499070764, + 1.5092291668988764, + 1.4499940001405776, + 1.444807792082429, + 1.445270833093673 ], - "mean_time": 1.1367310385816969, - "std_time": 0.011687519701604107, + "mean_time": 1.4499940001405776, + "std_time": 0.02615969854105174, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "CoarseDropout(hole_height_range=(16, 16), hole_width_range=(16, 16), num_holes_range=(1, 1), p=1.0)": { + "CoarseDropout(hole_height_range=(0.1, 0.1), hole_width_range=(0.1, 0.1), num_holes_range=(4, 4))": { "supported": false }, - "Blur(radius=5, p=1.0)": { + "Blur(radius=5, border_mode=constant)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 243.48089046250112, - 243.15675341289452, - 243.28203027519785, - 244.1412979970703, - 240.8076544035112, - 243.17949899867136, - 244.3248653384007, - 244.39103977859614, - 238.5083141746531, - 241.45891403936918, - 243.30027576382122, - 243.02256888424964, - 242.11874726111546, - 243.6799374835546, - 243.2645223208831, - 243.25223618073278, - 243.84561110003733, - 209.82980782180633, - 215.99684706332698, - 238.76649410249775 + 381.5071408115098, + 383.425916315969, + 386.2404914786257, + 386.9946357581195, + 392.64244018626266 ], - "median_throughput": 243.21586758970207, - "std_throughput": 9.356063902649074, + "median_throughput": 386.2404914786257, + "std_throughput": 4.2382017453845755, "times": [ - 4.107098500011489, - 4.112573415972292, - 4.110455666901544, - 4.095988709013909, - 4.152691917028278, - 4.112188749946654, - 4.092911290936172, - 4.0918030419852585, - 4.192725957836956, - 4.141491333954036, - 4.110147417057306, - 4.1148441669065505, - 4.130204749992117, - 4.103743666084483, - 4.110751499887556, - 4.11095912498422, - 4.100955500034615, - 4.765767125179991, - 4.629697208991274, - 4.188192333094776 + 5.242365832906216, + 5.216131499968469, + 5.178121000062674, + 5.168030290864408, + 5.0936928750015795 ], - "mean_time": 4.111573845531206, - "std_time": 0.15816462971957562, + "mean_time": 5.178121000062674, + "std_time": 0.05681931838959619, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "HSV(hue=0.015, saturation=0.7, value=0.4, p=1.0)": { + "HSV(hue=0.015, saturation=0.7, value=0.4)": { + "supported": false + }, + "ChannelDropout()": { + "supported": false + }, + "LinearIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "CornerIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "GaussianIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "Hue(hue=20)": { + "supported": false + }, + "PlasmaBrightness(roughness=0.5)": { + "supported": false + }, + "PlasmaContrast(roughness=0.5)": { + "supported": false + }, + "PlasmaShadow(roughness=0.5)": { + "supported": false + }, + "Rain(drop_width=5, drop_height=20)": { + "supported": false + }, + "SaltAndPepper(amount=(0.01, 0.06), salt_vs_pepper=(0.4, 0.6))": { + "supported": false + }, + "Saturation(saturation_factor=0.5)": { + "supported": false + }, + "Snow(snow_point_range=(0.5, 0.5))": { + "supported": false + }, + "OpticalDistortion(distort_limit=0.5)": { + "supported": false + }, + "Shear(shear=10)": { + "supported": false + }, + "ThinPlateSpline(num_control_points=4, distortion_scale=0.5)": { "supported": false } } diff --git a/output/comparison.csv b/output/comparison.csv new file mode 100644 index 0000000..2916178 --- /dev/null +++ b/output/comparison.csv @@ -0,0 +1,52 @@ +Transform,albumentations
2.0.2,augly
1.0.0,imgaug
0.4.0,kornia
0.8.0,torchvision
0.20.1 +Resize,**3662 ± 54**,1083 ± 21,2995 ± 70,645 ± 13,260 ± 9 +RandomCrop128,**116784 ± 2222**,45395 ± 934,21408 ± 622,2946 ± 42,31450 ± 249 +HorizontalFlip,**12649 ± 238**,8808 ± 1012,9599 ± 495,1297 ± 13,2486 ± 107 +VerticalFlip,**24989 ± 904**,16830 ± 1653,19935 ± 1708,2872 ± 37,4696 ± 161 +Rotate,**3066 ± 83**,1739 ± 105,2574 ± 10,256 ± 2,258 ± 4 +Affine,**1503 ± 29**,-,1328 ± 16,248 ± 6,188 ± 2 +Perspective,**1222 ± 16**,-,908 ± 8,154 ± 3,147 ± 5 +Elastic,359 ± 7,-,**395 ± 14**,1 ± 0,3 ± 0 +ChannelShuffle,**8162 ± 180**,-,1252 ± 26,1328 ± 44,4417 ± 234 +Grayscale,**37212 ± 1856**,6088 ± 107,3100 ± 24,1201 ± 52,2600 ± 23 +GaussianBlur,943 ± 11,387 ± 4,**1460 ± 23**,254 ± 5,127 ± 4 +GaussianNoise,234 ± 7,-,**263 ± 9**,125 ± 1,- +Invert,**35494 ± 17186**,-,3682 ± 79,2881 ± 43,4244 ± 30 +Posterize,**14146 ± 1381**,-,3111 ± 95,836 ± 30,4247 ± 26 +Solarize,**12920 ± 1097**,-,3843 ± 80,263 ± 6,1032 ± 14 +Sharpen,**2375 ± 38**,-,1101 ± 30,201 ± 2,220 ± 3 +Equalize,**1303 ± 64**,-,814 ± 11,306 ± 1,795 ± 3 +JpegCompression,**1354 ± 23**,1202 ± 19,687 ± 26,120 ± 1,889 ± 7 +RandomGamma,**12631 ± 1159**,-,3504 ± 72,230 ± 3,- +MedianBlur,**1259 ± 8**,-,1152 ± 14,6 ± 0,- +MotionBlur,**3608 ± 18**,-,928 ± 37,159 ± 1,- +CLAHE,**649 ± 13**,-,555 ± 14,165 ± 3,- +Brightness,**11254 ± 418**,2108 ± 32,1076 ± 32,1127 ± 27,854 ± 13 +Contrast,**11255 ± 242**,1379 ± 25,717 ± 5,1109 ± 41,602 ± 13 +CoarseDropout,**15760 ± 594**,-,1190 ± 22,-,- +Blur,**7403 ± 114**,386 ± 4,5381 ± 125,265 ± 11,- +Saturation,**1581 ± 127**,-,495 ± 3,155 ± 2,- +Shear,**1336 ± 18**,-,1244 ± 14,261 ± 1,- +ColorJitter,**968 ± 52**,418 ± 5,-,104 ± 4,87 ± 1 +RandomResizedCrop,**4521 ± 17**,-,-,661 ± 16,837 ± 37 +Pad,**31866 ± 530**,-,-,-,4889 ± 183 +AutoContrast,**1534 ± 115**,-,-,541 ± 8,344 ± 1 +Normalize,**1797 ± 190**,-,-,1251 ± 14,1018 ± 7 +Erasing,**25411 ± 5727**,-,-,1210 ± 27,3577 ± 49 +CenterCrop128,**119630 ± 3484**,-,-,-,- +RGBShift,**3526 ± 128**,-,-,896 ± 9,- +PlankianJitter,**3351 ± 42**,-,-,2150 ± 52,- +HSV,**1277 ± 91**,-,-,-,- +ChannelDropout,**10988 ± 243**,-,-,2283 ± 24,- +LinearIllumination,462 ± 52,-,-,**708 ± 6**,- +CornerIllumination,**464 ± 45**,-,-,452 ± 3,- +GaussianIllumination,**670 ± 91**,-,-,436 ± 13,- +Hue,**1846 ± 193**,-,-,150 ± 1,- +PlasmaBrightness,**163 ± 1**,-,-,85 ± 1,- +PlasmaContrast,**138 ± 4**,-,-,84 ± 0,- +PlasmaShadow,190 ± 3,-,-,**216 ± 5**,- +Rain,**2121 ± 64**,-,-,1493 ± 9,- +SaltAndPepper,**2233 ± 35**,-,-,480 ± 12,- +Snow,**588 ± 32**,-,-,143 ± 1,- +OpticalDistortion,**687 ± 38**,-,-,174 ± 0,- +ThinPlateSpline,**75 ± 5**,-,-,58 ± 0,- diff --git a/output/comparison.md b/output/comparison.md index bc7142a..97886db 100644 --- a/output/comparison.md +++ b/output/comparison.md @@ -2,55 +2,78 @@ ### System Information -- Platform: macOS-15.0.1-arm64-arm-64bit +- Platform: macOS-15.1-arm64-arm-64bit - Processor: arm -- CPU Count: 10 -- Python Version: 3.12.7 +- CPU Count: 16 +- Python Version: 3.12.8 ### Benchmark Parameters -- Number of images: 1000 -- Runs per transform: 20 +- Number of images: 2000 +- Runs per transform: 5 - Max warmup iterations: 1000 ### Library Versions -- albumentations: 1.4.21 +- albumentations: 2.0.2 - augly: 1.0.0 - imgaug: 0.4.0 -- kornia: 0.7.3 +- kornia: 0.8.0 - torchvision: 0.20.1 ## Performance Comparison -| Transform | albumentations
1.4.21 | augly
1.0.0 | imgaug
0.4.0 | kornia
0.7.3 | torchvision
0.20.1 | -|:------------------|:---------------------------|:-----------------|:------------------|:------------------|:------------------------| -| HorizontalFlip | **8622 ± 891** | 4121 ± 1001 | 6162 ± 393 | 571 ± 84 | 861 ± 38 | -| VerticalFlip | **23951 ± 5013** | 7775 ± 1376 | 11663 ± 2258 | 1590 ± 100 | 3156 ± 402 | -| Rotate | 1163 ± 84 | 1095 ± 82 | **1224 ± 75** | 167 ± 11 | 160 ± 11 | -| Affine | **907 ± 49** | - | 890 ± 34 | 181 ± 6 | 129 ± 16 | -| Equalize | **852 ± 90** | - | 610 ± 35 | 184 ± 9 | 416 ± 44 | -| RandomCrop80 | **107764 ± 3630** | 25192 ± 5964 | 12343 ± 2013 | 1492 ± 22 | 28767 ± 858 | -| ShiftRGB | **2351 ± 276** | - | 1674 ± 63 | - | - | -| Resize | **2372 ± 156** | 632 ± 38 | 2025 ± 74 | 332 ± 18 | 180 ± 11 | -| RandomGamma | **9014 ± 371** | - | 2592 ± 143 | 128 ± 10 | - | -| Grayscale | **11373 ± 923** | 3359 ± 65 | 1849 ± 75 | 628 ± 75 | 1497 ± 317 | -| RandomPerspective | 401 ± 24 | - | **596 ± 38** | 98 ± 7 | 106 ± 4 | -| GaussianBlur | **1664 ± 144** | 235 ± 18 | 1043 ± 142 | 165 ± 12 | 82 ± 3 | -| MedianBlur | 847 ± 36 | - | **849 ± 32** | 4 ± 0 | - | -| MotionBlur | **3928 ± 742** | - | 663 ± 36 | 75 ± 6 | - | -| Posterize | **9034 ± 331** | - | 2400 ± 142 | 363 ± 69 | 3052 ± 380 | -| JpegCompression | **906 ± 40** | 754 ± 14 | 443 ± 79 | 69 ± 3 | 606 ± 42 | -| GaussianNoise | 183 ± 5 | 70 ± 1 | **204 ± 18** | 65 ± 2 | - | -| Elastic | 229 ± 17 | - | **251 ± 22** | 1 ± 0 | 3 ± 0 | -| Clahe | **471 ± 18** | - | 422 ± 12 | 90 ± 2 | - | -| Brightness | **9251 ± 709** | 1297 ± 42 | 742 ± 39 | 519 ± 15 | 449 ± 14 | -| Contrast | **9146 ± 1034** | 880 ± 9 | 510 ± 9 | 476 ± 116 | 358 ± 4 | -| CoarseDropout | **14488 ± 2108** | - | 653 ± 85 | 526 ± 86 | - | -| Blur | **5804 ± 305** | 243 ± 9 | 3857 ± 385 | - | - | -| ColorJitter | **700 ± 31** | 252 ± 15 | - | 50 ± 4 | 47 ± 2 | -| RandomResizedCrop | **2879 ± 158** | - | - | 321 ± 10 | 462 ± 47 | -| Normalize | **1349 ± 65** | - | - | 645 ± 40 | 528 ± 20 | -| PlankianJitter | **2155 ± 340** | - | - | 1023 ± 114 | - | -| HSV | **1243 ± 44** | - | - | - | - | +| Transform | albumentations
2.0.2 | augly
1.0.0 | imgaug
0.4.0 | kornia
0.8.0 | torchvision
0.20.1 | +|:---------------------|:--------------------------|:-----------------|:------------------|:------------------|:------------------------| +| Resize | **3662 ± 54** | 1083 ± 21 | 2995 ± 70 | 645 ± 13 | 260 ± 9 | +| RandomCrop128 | **116784 ± 2222** | 45395 ± 934 | 21408 ± 622 | 2946 ± 42 | 31450 ± 249 | +| HorizontalFlip | **12649 ± 238** | 8808 ± 1012 | 9599 ± 495 | 1297 ± 13 | 2486 ± 107 | +| VerticalFlip | **24989 ± 904** | 16830 ± 1653 | 19935 ± 1708 | 2872 ± 37 | 4696 ± 161 | +| Rotate | **3066 ± 83** | 1739 ± 105 | 2574 ± 10 | 256 ± 2 | 258 ± 4 | +| Affine | **1503 ± 29** | - | 1328 ± 16 | 248 ± 6 | 188 ± 2 | +| Perspective | **1222 ± 16** | - | 908 ± 8 | 154 ± 3 | 147 ± 5 | +| Elastic | 359 ± 7 | - | **395 ± 14** | 1 ± 0 | 3 ± 0 | +| ChannelShuffle | **8162 ± 180** | - | 1252 ± 26 | 1328 ± 44 | 4417 ± 234 | +| Grayscale | **37212 ± 1856** | 6088 ± 107 | 3100 ± 24 | 1201 ± 52 | 2600 ± 23 | +| GaussianBlur | 943 ± 11 | 387 ± 4 | **1460 ± 23** | 254 ± 5 | 127 ± 4 | +| GaussianNoise | 234 ± 7 | - | **263 ± 9** | 125 ± 1 | - | +| Invert | **35494 ± 17186** | - | 3682 ± 79 | 2881 ± 43 | 4244 ± 30 | +| Posterize | **14146 ± 1381** | - | 3111 ± 95 | 836 ± 30 | 4247 ± 26 | +| Solarize | **12920 ± 1097** | - | 3843 ± 80 | 263 ± 6 | 1032 ± 14 | +| Sharpen | **2375 ± 38** | - | 1101 ± 30 | 201 ± 2 | 220 ± 3 | +| Equalize | **1303 ± 64** | - | 814 ± 11 | 306 ± 1 | 795 ± 3 | +| JpegCompression | **1354 ± 23** | 1202 ± 19 | 687 ± 26 | 120 ± 1 | 889 ± 7 | +| RandomGamma | **12631 ± 1159** | - | 3504 ± 72 | 230 ± 3 | - | +| MedianBlur | **1259 ± 8** | - | 1152 ± 14 | 6 ± 0 | - | +| MotionBlur | **3608 ± 18** | - | 928 ± 37 | 159 ± 1 | - | +| CLAHE | **649 ± 13** | - | 555 ± 14 | 165 ± 3 | - | +| Brightness | **11254 ± 418** | 2108 ± 32 | 1076 ± 32 | 1127 ± 27 | 854 ± 13 | +| Contrast | **11255 ± 242** | 1379 ± 25 | 717 ± 5 | 1109 ± 41 | 602 ± 13 | +| CoarseDropout | **15760 ± 594** | - | 1190 ± 22 | - | - | +| Blur | **7403 ± 114** | 386 ± 4 | 5381 ± 125 | 265 ± 11 | - | +| Saturation | **1581 ± 127** | - | 495 ± 3 | 155 ± 2 | - | +| Shear | **1336 ± 18** | - | 1244 ± 14 | 261 ± 1 | - | +| ColorJitter | **968 ± 52** | 418 ± 5 | - | 104 ± 4 | 87 ± 1 | +| RandomResizedCrop | **4521 ± 17** | - | - | 661 ± 16 | 837 ± 37 | +| Pad | **31866 ± 530** | - | - | - | 4889 ± 183 | +| AutoContrast | **1534 ± 115** | - | - | 541 ± 8 | 344 ± 1 | +| Normalize | **1797 ± 190** | - | - | 1251 ± 14 | 1018 ± 7 | +| Erasing | **25411 ± 5727** | - | - | 1210 ± 27 | 3577 ± 49 | +| CenterCrop128 | **119630 ± 3484** | - | - | - | - | +| RGBShift | **3526 ± 128** | - | - | 896 ± 9 | - | +| PlankianJitter | **3351 ± 42** | - | - | 2150 ± 52 | - | +| HSV | **1277 ± 91** | - | - | - | - | +| ChannelDropout | **10988 ± 243** | - | - | 2283 ± 24 | - | +| LinearIllumination | 462 ± 52 | - | - | **708 ± 6** | - | +| CornerIllumination | **464 ± 45** | - | - | 452 ± 3 | - | +| GaussianIllumination | **670 ± 91** | - | - | 436 ± 13 | - | +| Hue | **1846 ± 193** | - | - | 150 ± 1 | - | +| PlasmaBrightness | **163 ± 1** | - | - | 85 ± 1 | - | +| PlasmaContrast | **138 ± 4** | - | - | 84 ± 0 | - | +| PlasmaShadow | 190 ± 3 | - | - | **216 ± 5** | - | +| Rain | **2121 ± 64** | - | - | 1493 ± 9 | - | +| SaltAndPepper | **2233 ± 35** | - | - | 480 ± 12 | - | +| Snow | **588 ± 32** | - | - | 143 ± 1 | - | +| OpticalDistortion | **687 ± 38** | - | - | 174 ± 0 | - | +| ThinPlateSpline | **75 ± 5** | - | - | 58 ± 0 | - | diff --git a/output/imgaug_results.json b/output/imgaug_results.json index 9c61193..3a76eac 100644 --- a/output/imgaug_results.json +++ b/output/imgaug_results.json @@ -1,19 +1,19 @@ { "metadata": { "system_info": { - "python_version": "3.12.7 | packaged by Anaconda, Inc. | (main, Oct 4 2024, 08:22:19) [Clang 14.0.6 ]", - "platform": "macOS-15.0.1-arm64-arm-64bit", + "python_version": "3.12.8 | packaged by Anaconda, Inc. | (main, Dec 11 2024, 10:37:40) [Clang 14.0.6 ]", + "platform": "macOS-15.1-arm64-arm-64bit", "processor": "arm", - "cpu_count": "10", - "timestamp": "2024-11-02T16:41:56.062018+00:00" + "cpu_count": "16", + "timestamp": "2025-01-25T02:20:05.295158+00:00" }, "library_versions": { "imgaug": "0.4.0", "numpy": "1.26.4", - "pillow": "11.0.0", + "pillow": "11.1.0", "opencv-python-headless": "not installed", "torch": "not installed", - "opencv-python": "4.10.0.84" + "opencv-python": "4.11.0.86" }, "thread_settings": { "environment": "{'OMP_NUM_THREADS': '1', 'OPENBLAS_NUM_THREADS': '1', 'MKL_NUM_THREADS': '1', 'VECLIB_MAXIMUM_THREADS': '1', 'NUMEXPR_NUM_THREADS': '1'}", @@ -22,8 +22,8 @@ "pillow": "{'threads': 'unknown', 'simd': False}" }, "benchmark_params": { - "num_images": 1000, - "num_runs": 20, + "num_images": 2000, + "num_runs": 5, "max_warmup_iterations": 1000, "warmup_window": 5, "warmup_threshold": 0.05, @@ -31,1284 +31,770 @@ } }, "results": { - "HorizontalFlip(p=1.0)": { + "Resize(target_size=512, interpolation=bilinear)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 4574.235843561762, - 6243.33391255051, - 6166.598368616923, - 5905.164521741738, - 6436.122980066613, - 5868.359490263609, - 6204.729708611467, - 6113.6636952986255, - 6284.747780513081, - 5992.699410558621, - 6079.225990733306, - 6364.1334562872535, - 6158.248490519357, - 6146.80570057985, - 6172.46484716778, - 6247.122105291933, - 6212.1447382427505, - 5644.349547275563, - 6117.690600790493, - 6267.054848616496 - ], - "median_throughput": 6162.42342956814, - "std_throughput": 392.9200185307556, + 2871.140178629343, + 3032.837097878637, + 2991.0565509426106, + 3051.8363965283115, + 2995.316446395427 + ], + "median_throughput": 2995.316446395427, + "std_throughput": 70.36260602183674, "times": [ - 0.21861575008369982, - 0.1601708340458572, - 0.1621639581862837, - 0.16934329201467335, - 0.15537304105237126, - 0.17040537507273257, - 0.1611673750448972, - 0.1635680419858545, - 0.15911537501960993, - 0.16686970787122846, - 0.16449462505988777, - 0.1571305829565972, - 0.16238383390009403, - 0.16268612490966916, - 0.1620098331477493, - 0.16007370804436505, - 0.16097500012256205, - 0.17716833297163248, - 0.16346037504263222, - 0.1595645840279758 - ], - "mean_time": 0.16227382156212522, - "std_time": 0.01034668157811335, + 0.6965873748995364, + 0.6594485412351787, + 0.6686600423417985, + 0.6553431246429682, + 0.6677090837620199 + ], + "mean_time": 0.6677090837620199, + "std_time": 0.015685071022958717, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "VerticalFlip(p=1.0)": { + "RandomCrop128(height=128, width=128)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 12203.592431960249, - 12082.852199825746, - 12858.070450925306, - 10621.334804164884, - 10289.803775445678, - 10494.48259066556, - 11783.368664961052, - 10713.482124669652, - 4442.313770650139, - 7178.108890835767, - 12066.50449385896, - 12221.340595093901, - 12933.82189644121, - 10331.823672006734, - 11000.379084401742, - 10387.137351469002, - 11541.907547708268, - 12889.435411780772, - 14263.35993260443, - 14302.698719679263 - ], - "median_throughput": 11662.63810633466, - "std_throughput": 2257.5478482280355, + 20358.711935300194, + 21708.966050684176, + 21407.765629167334, + 21892.217294699953, + 20923.639092158137 + ], + "median_throughput": 21407.765629167334, + "std_throughput": 622.2032628991525, "times": [ - 0.08194308402016759, - 0.0827619160991162, - 0.07777216681279242, - 0.09415012504905462, - 0.09718358307145536, - 0.09528816607780755, - 0.08486537495627999, - 0.09334033401682973, - 0.22510791709646583, - 0.13931245892308652, - 0.0828740419819951, - 0.08182408404536545, - 0.07731666695326567, - 0.09678833396174014, - 0.09090595808811486, - 0.09627291583456099, - 0.0866407910361886, - 0.07758291717618704, - 0.07010970800183713, - 0.06991687510162592 - ], - "mean_time": 0.08574389352412827, - "std_time": 0.016597526268001907, + 0.09823804209008813, + 0.09212783304974437, + 0.09342404222115874, + 0.0913566667586565, + 0.09558566706255078 + ], + "mean_time": 0.09342404222115874, + "std_time": 0.002715311112339289, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Rotate(angle=45, p=1.0, interpolation=nearest, mode=reflect)": { + "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear)": { + "supported": false + }, + "CenterCrop128(height=128, width=128)": { + "supported": false + }, + "HorizontalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 1220.8781777596732, - 1220.8946976345624, - 1227.658909766594, - 1233.6147693531161, - 1239.488683573918, - 1219.0352965754973, - 1220.5579798653466, - 1254.8886399178011, - 1230.8364533142403, - 1223.095342259764, - 1216.7273864668207, - 1185.001845788932, - 1179.1860678204616, - 903.2934077095716, - 1224.3714808053014, - 1227.264289373592, - 1240.1294099647644, - 1206.639169517073, - 1252.9085756750574, - 1268.025376979914 - ], - "median_throughput": 1223.7334115325327, - "std_throughput": 75.08195317895603, + 9251.012958631156, + 9891.91635859715, + 10287.247788146442, + 9049.04525061468, + 9598.792464054242 + ], + "median_throughput": 9598.792464054242, + "std_throughput": 495.39175643024885, "times": [ - 0.8190825409255922, - 0.8190714579541236, - 0.8145584999583662, - 0.8106258329935372, - 0.8067842919845134, - 0.8203207920305431, - 0.8192974168341607, - 0.7968834589701146, - 0.8124556250404567, - 0.8175977501086891, - 0.8218767910730094, - 0.8438805420883, - 0.8480425840243697, - 1.1070600000675768, - 0.8167455838993192, - 0.8148204169701785, - 0.8063674580771476, - 0.828748167026788, - 0.7981428329367191, - 0.7886277500074357 - ], - "mean_time": 0.8171714448391648, - "std_time": 0.05013741357585128, + 0.21619254117831588, + 0.20218529226258397, + 0.19441545894369483, + 0.2210177918896079, + 0.20835954183712602 + ], + "mean_time": 0.20835954183712604, + "std_time": 0.010753394219766153, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Affine(angle=25.0, shift=(50, 50), scale=2.0, shear=[10.0, 15.0], p=1.0, interpolation=bilinear, mode=reflect)": { + "VerticalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 889.4446272355084, - 907.2248095097814, - 888.8491214924832, - 889.397294572027, - 903.715547540026, - 889.9047312891619, - 862.4478037946034, - 883.582550042376, - 897.2275559150794, - 892.6025119716812, - 886.8749269044044, - 889.6415587665109, - 903.8857254340578, - 905.7670527839788, - 888.4659136512427, - 904.0742216108487, - 893.9980878948367, - 895.7905570184519, - 816.0645571557836, - 765.1006722552042 - ], - "median_throughput": 889.7731450278363, - "std_throughput": 34.0655395880381, + 19935.26025297504, + 20238.852204531526, + 16544.039779585644, + 20703.656835937985, + 18332.316786177922 + ], + "median_throughput": 19935.26025297504, + "std_throughput": 1708.4871565275241, "times": [ - 1.1242970831226557, - 1.1022626250050962, - 1.1250503328628838, - 1.1243569168727845, - 1.1065428748261184, - 1.1237157920841128, - 1.1594904591329396, - 1.1317561669275165, - 1.1145444579888135, - 1.1203195000998676, - 1.127554708858952, - 1.1240482081193477, - 1.1063345419242978, - 1.10403662500903, - 1.125535582890734, - 1.106103875208646, - 1.118570625083521, - 1.1163323749788105, - 1.225393250118941, - 1.3070175419561565 - ], - "mean_time": 1.1238819755216543, - "std_time": 0.04302854738127393, + 0.10032474994659424, + 0.09881983324885368, + 0.12088945787400007, + 0.09660129202529788, + 0.10909695830196142 + ], + "mean_time": 0.10032474994659424, + "std_time": 0.008598008984608678, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Equalize(p=1.0)": { + "Pad(padding=10, fill=0, border_mode=constant)": { + "supported": false + }, + "Rotate(angle=45, interpolation=nearest, mode=constant, fill=0)": { "supported": true, - "warmup_iterations": 30, + "warmup_iterations": 16, "throughputs": [ - 573.2450349341254, - 611.7189290752481, - 604.3954661882544, - 617.0327257371468, - 627.19277368235, - 604.7106964611817, - 591.7149844113849, - 620.6518970554868, - 612.5559732345624, - 634.9820165558556, - 637.467977268458, - 527.4834827041075, - 609.0243555498454, - 625.763235589292, - 603.423948077534, - 615.4168851444887, - 621.473799956126, - 516.1050138204116, - 596.6796416983349, - 534.120567764543 - ], - "median_throughput": 610.3716423125468, - "std_throughput": 35.01688004633133, + 2591.2262810032353, + 2566.0960890941196, + 2573.7254364560426, + 2585.6486711696143, + 2574.4302638597546 + ], + "median_throughput": 2574.4302638597546, + "std_throughput": 10.07348965076161, "times": [ - 1.7444547079503536, - 1.634737707907334, - 1.6545458328910172, - 1.6206595830153674, - 1.5944061251357198, - 1.65368333295919, - 1.6900028330273926, - 1.6112091250251979, - 1.632503875065595, - 1.5748477499000728, - 1.5687062498182058, - 1.8957939590327442, - 1.6419704579748213, - 1.5980485000181943, - 1.6572096669115126, - 1.6249147921334952, - 1.6090782911051065, - 1.9375901671592146, - 1.6759412088431418, - 1.872236458119005 - ], - "mean_time": 1.6383461004368551, - "std_time": 0.0939915371166528, + 0.7718353332020342, + 0.7793940408155322, + 0.7770836669951677, + 0.7735002911649644, + 0.7768709170632064 + ], + "mean_time": 0.7768709170632064, + "std_time": 0.003039818655363745, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomCrop80(height=80, width=80, p=1.0)": { + "Affine(angle=25.0, shift=(20, 20), scale=2.0, shear=(10.0, 15.0), interpolation=bilinear, mode=constant, fill=0)": { "supported": true, - "warmup_iterations": 17, + "warmup_iterations": 16, "throughputs": [ - 10500.166633657102, - 12732.980281912345, - 11510.824494609986, - 10936.58638321019, - 13169.338556211147, - 13236.121267227825, - 13184.241508509485, - 12475.069338241357, - 12791.779231830444, - 12211.13670459124, - 12173.150878774692, - 12547.759916234198, - 12791.55422906641, - 7007.246058254994, - 11302.819490185064, - 11319.702789307226, - 5771.360345885648, - 11570.00085246907, - 13218.166280024408, - 13475.91608296471 - ], - "median_throughput": 12343.103021416298, - "std_throughput": 2012.8963927217767, + 1344.8196623617882, + 1328.1363721044956, + 1331.6815308897264, + 1307.0851389516781, + 1308.6957546327799 + ], + "median_throughput": 1328.1363721044956, + "std_throughput": 16.045803663440147, "times": [ - 0.09523658384568989, - 0.07853620895184577, - 0.08687474997714162, - 0.09143620915710926, - 0.07593395793810487, - 0.07555083394981921, - 0.07584812515415251, - 0.08015987509861588, - 0.07817520783282816, - 0.08189245802350342, - 0.08214800013229251, - 0.07969549996778369, - 0.07817658293060958, - 0.1427094170358032, - 0.08847349998541176, - 0.08834154205396771, - 0.17326937499456108, - 0.08643041714094579, - 0.07565345894545317, - 0.07420645793899894 - ], - "mean_time": 0.08101690460372224, - "std_time": 0.013212126216832345, + 1.4871882498264313, + 1.5058694588951766, + 1.5018605827353895, + 1.5301222088746727, + 1.5282390830107033 + ], + "mean_time": 1.5058694588951769, + "std_time": 0.018193075792296547, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Perspective(scale=(0.05, 0.1), interpolation=bilinear, fill=0)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 910.1977647389754, + 894.7672279102222, + 907.7090425540082, + 908.6570940235168, + 893.7570344195453 + ], + "median_throughput": 907.7090425540082, + "std_throughput": 8.049767174303797, + "times": [ + 2.197324666660279, + 2.235218208283186, + 2.203349207993597, + 2.2010503336787224, + 2.2377446251921356 + ], + "mean_time": 2.203349207993597, + "std_time": 0.019539794467762852, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 418.20951854291206, + 395.32852801451503, + 400.6208287393228, + 381.3922200428911, + 389.02032284877214 + ], + "median_throughput": 395.32852801451503, + "std_throughput": 13.901341682850362, + "times": [ + 4.78229191666469, + 5.0590834161266685, + 4.992251666728407, + 5.243945457972586, + 5.141119583044201 + ], + "mean_time": 5.0590834161266685, + "std_time": 0.1778977285621959, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear, p=1.0)": { + "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5)": { "supported": false }, - "ShiftRGB(pixel_shift=100, p=1.0, per_channel=True)": { + "ChannelShuffle()": { "supported": true, "warmup_iterations": 17, "throughputs": [ - 1680.6428474423465, - 1537.3347522488725, - 1609.5507528037494, - 1660.426115773741, - 1656.978978563198, - 1722.6050357705149, - 1620.3510677921704, - 1788.3190554219855, - 1704.483595056454, - 1694.697193115982, - 1665.3612090907268, - 1666.064686857084, - 1798.499959631848, - 1648.6626988912308, - 1667.854896834741, - 1683.0188301079788, - 1757.5962761044948, - 1701.9519110725344, - 1658.5636626516266, - 1770.4870446771336 - ], - "median_throughput": 1674.248872138544, - "std_throughput": 62.599333087173214, + 1218.2024729832947, + 1264.7629120321144, + 1251.8559093899385, + 1231.3666967775625, + 1283.5330699776564 + ], + "median_throughput": 1251.8559093899385, + "std_throughput": 26.00058607724153, "times": [ - 0.5950104161165655, - 0.6504764161072671, - 0.6212913747876883, - 0.602255041943863, - 0.6035079581197351, - 0.5805161248426884, - 0.6171502089127898, - 0.5591843340080231, - 0.5866879581008106, - 0.5900759168434888, - 0.6004703331273049, - 0.6002167910337448, - 0.5560189171228558, - 0.6065522078424692, - 0.5995725418906659, - 0.594170416938141, - 0.5689588750246912, - 0.5875606669578701, - 0.602931333007291, - 0.5648163328878582 - ], - "mean_time": 0.5972827675987529, - "std_time": 0.022332105780895534, + 1.6417632079683244, + 1.5813240418210626, + 1.597627957817167, + 1.6242115409113467, + 1.5581990419887006 + ], + "mean_time": 1.597627957817167, + "std_time": 0.03318214414698574, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Resize(target_size=512, interpolation=bilinear, p=1.0)": { + "Grayscale(num_output_channels=1)": { "supported": true, - "warmup_iterations": 38, + "warmup_iterations": 16, "throughputs": [ - 2083.3778217922463, - 2079.4794383942412, - 2030.8625106841264, - 1871.6208471511134, - 1962.6493111055545, - 1938.9928206083941, - 1879.0038931914028, - 2093.480169691493, - 2067.2888765820758, - 2096.2771144472795, - 2042.4535860574858, - 2018.8437176951993, - 2079.4055660151957, - 2041.3004391724753, - 1907.0685488736772, - 1939.8686009000023, - 1980.280202985163, - 2092.835390074406, - 1963.8219801910636, - 2001.0857568648837 - ], - "median_throughput": 2024.8531141896628, - "std_throughput": 74.08669810638884, + 3099.634657317826, + 3149.0975682261987, + 3099.592618414442, + 3126.5893489180585, + 3091.4616631509616 + ], + "median_throughput": 3099.634657317826, + "std_throughput": 24.029234590990832, "times": [ - 0.479989750077948, - 0.4808895830065012, - 0.4924016247969121, - 0.5342962499707937, - 0.5095153751317412, - 0.5157316671684384, - 0.5321968749631196, - 0.47767350007779896, - 0.48372533288784325, - 0.4770361671689898, - 0.48960720910690725, - 0.4953330419957638, - 0.4809066669549793, - 0.48988379212096334, - 0.5243650001939386, - 0.5154988330323249, - 0.5049790421035141, - 0.4778206660412252, - 0.5092111250851303, - 0.49972870806232095 - ], - "mean_time": 0.49386298343926816, - "std_time": 0.01806979355864447, + 0.6452373331412673, + 0.6351025830954313, + 0.6452460843138397, + 0.6396746668033302, + 0.6469431673176587 + ], + "mean_time": 0.6452373331412673, + "std_time": 0.005002060229360453, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomGamma(gamma=120, p=1.0)": { + "RGBShift(pixel_shift=100)": { + "supported": false + }, + "GaussianBlur(sigma=2.0, kernel_size=(5, 5))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 2693.9325543340165, - 2456.5206102190077, - 2499.6406766811283, - 2452.4488073665198, - 2714.3401367458696, - 2473.989612097606, - 2505.456414318121, - 2650.3739335843075, - 2497.972739229228, - 2516.1959103423933, - 2570.2607572732254, - 2613.0247525086547, - 2647.487384783739, - 2761.8428335035896, - 2845.48112373348, - 2849.2166137351714, - 2836.3580980598695, - 2720.7907555134916, - 2452.822510053094, - 2436.4069880192487 - ], - "median_throughput": 2591.64275489094, - "std_throughput": 142.89724484960064, + 1464.7046456946862, + 1459.958626435828, + 1461.423400666134, + 1451.9304843830894, + 1410.2126416306055 + ], + "median_throughput": 1459.958626435828, + "std_throughput": 22.53901540546559, "times": [ - 0.3712045419961214, - 0.4070798330940306, - 0.40005749999545515, - 0.40775570808909833, - 0.3684136657975614, - 0.40420541586354375, - 0.39912887499667704, - 0.37730525014922023, - 0.4003246249631047, - 0.397425333969295, - 0.3890655830036849, - 0.38269825000315905, - 0.3777166251093149, - 0.3620770841371268, - 0.3514344170689583, - 0.35097366594709456, - 0.3525647909846157, - 0.3675402079243213, - 0.40769358398392797, - 0.4104404579848051 - ], - "mean_time": 0.38585565009405837, - "std_time": 0.021275196669771238, + 1.3654630002565682, + 1.3699018340557814, + 1.3685287912376225, + 1.3774764160625637, + 1.418225834146142 + ], + "mean_time": 1.3699018340557814, + "std_time": 0.02114870790354961, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Grayscale(p=1.0, num_output_channels=3)": { + "GaussianNoise(mean=0, std=0.44, per_channel=True)": { + "supported": true, + "warmup_iterations": 27, + "throughputs": [ + 273.03574107225467, + 275.88964205875817, + 252.88516952632162, + 262.5485159050665, + 260.55877382647566 + ], + "median_throughput": 262.5485159050665, + "std_throughput": 9.429468044005166, + "times": [ + 7.325048333033919, + 7.2492754170671105, + 7.908727916888893, + 7.617639707867056, + 7.67581137502566 + ], + "mean_time": 7.617639707867057, + "std_time": 0.27358863541262596, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Invert()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 1906.4600153562774, - 1894.0087438110831, - 1945.8854134671303, - 1934.475914762276, - 1932.1232250115686, - 1842.2308867201655, - 1896.1668511574537, - 1839.6786034134464, - 1853.1703757466685, - 1905.2315569682416, - 1827.6803558005931, - 1845.2508087283543, - 1722.0090466151455, - 1787.3823758866383, - 1837.8238383280273, - 1832.5326309388925, - 1754.1198959112276, - 1704.8368996971562, - 1942.938802253141, - 1965.7460571305423 - ], - "median_throughput": 1849.2105922375113, - "std_throughput": 74.58439344266874, + 3796.9354565325107, + 3734.2200048752507, + 3680.615794283468, + 3682.4085345857943, + 3582.386566135254 + ], + "median_throughput": 3682.4085345857943, + "std_throughput": 79.01865483638375, "times": [ - 0.5245323751587421, - 0.5279806670732796, - 0.5139048749115318, - 0.5169358751736581, - 0.5175653328187764, - 0.54282012488693, - 0.5273797500412911, - 0.5435732079204172, - 0.5396157919894904, - 0.5248705840203911, - 0.5471416250802577, - 0.5419317500200123, - 0.5807170420885086, - 0.5594773751217872, - 0.5441217918414623, - 0.5456928750500083, - 0.5700864589307457, - 0.5865663748700172, - 0.5146842498797923, - 0.5087127080187201 - ], - "mean_time": 0.5407712913811608, - "std_time": 0.0218109819012394, + 0.5267405840568244, + 0.5355870830826461, + 0.5433873329311609, + 0.5431227907538414, + 0.5582870421931148 + ], + "mean_time": 0.5431227907538414, + "std_time": 0.0116545548744169, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5, p=1.0)": { - "supported": false + "Posterize(bits=4)": { + "supported": true, + "warmup_iterations": 20, + "throughputs": [ + 3044.9935861170466, + 3110.9553347216774, + 3188.8913912410408, + 3269.70554571535, + 3057.497580329957 + ], + "median_throughput": 3110.9553347216774, + "std_throughput": 94.51725155741237, + "times": [ + 0.6568158334121108, + 0.6428893329575658, + 0.6271772081963718, + 0.6116758747957647, + 0.654129708185792 + ], + "mean_time": 0.6428893329575658, + "std_time": 0.01953230640393092, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "PlankianJitter(mode=blackbody, p=1.0)": { - "supported": false + "Solarize(threshold=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 3691.9274270365577, + 3842.584984057338, + 3845.148504364967, + 3901.0837983613524, + 3774.770456240433 + ], + "median_throughput": 3842.584984057338, + "std_throughput": 80.26460410510607, + "times": [ + 0.5417224578559399, + 0.5204829582944512, + 0.5201359577476978, + 0.5126780411228538, + 0.5298335417173803 + ], + "mean_time": 0.5204829582944512, + "std_time": 0.010871941353095962, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "RandomPerspective(scale=(0.05, 0.1), p=1.0, interpolation=bilinear)": { + "Sharpen(alpha=(0.2, 0.5), lightness=(0.5, 1))": { "supported": true, - "warmup_iterations": 21, + "warmup_iterations": 18, "throughputs": [ - 607.6190568610984, - 557.1734606392391, - 595.0163071729478, - 614.48441161514, - 513.3172897077534, - 580.5217675790329, - 597.4219747710771, - 603.2038418445499, - 595.963553518221, - 595.532848547545, - 598.8100445415452, - 612.0052635230226, - 603.0128635948906, - 605.7634606886487, - 585.6239137351283, - 609.9692769812177, - 488.87862241276315, - 570.8580803231105, - 573.5731341522537, - 498.5589465288964 - ], - "median_throughput": 595.748201032883, - "std_throughput": 37.72663395009009, + 1081.0426601997349, + 1143.276180553824, + 1106.7739407828021, + 1101.4567661653368, + 1064.1400196991879 + ], + "median_throughput": 1101.4567661653368, + "std_throughput": 29.84946972475073, "times": [ - 1.6457680000457913, - 1.7947732091415673, - 1.6806262079626322, - 1.6273805829696357, - 1.9481128340121359, - 1.7225882918573916, - 1.6738587501458824, - 1.657814374892041, - 1.6779549589846283, - 1.6791685000061989, - 1.6699786670506, - 1.6339728750754148, - 1.6583394159097224, - 1.650809375103563, - 1.7075805419590324, - 1.6394268330186605, - 2.0454975001048297, - 1.7517488750163466, - 1.7434568330645561, - 2.005780874984339 - ], - "mean_time": 1.6785615101585576, - "std_time": 0.10629738461093054, + 1.8500657500699162, + 1.7493585837073624, + 1.8070537499152124, + 1.815777124837041, + 1.8794519170187414 + ], + "mean_time": 1.8157771248370407, + "std_time": 0.04920754584259583, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianBlur(sigma=2.0, kernel_size=(5, 5), p=1.0)": { + "Equalize()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 813.1901062110176, - 886.7296037612235, - 712.5122799233043, - 1113.8608524894253, - 1060.205537942633, - 1051.305274218424, - 904.1627085800652, - 893.555166541277, - 932.2976337843883, - 1034.8770826854766, - 1066.3196617421777, - 1079.468442679411, - 1143.4702599628026, - 948.5833442799286, - 680.541779274933, - 929.9648511424404, - 1133.8808020460453, - 1146.0560038152562, - 1083.1617765187627, - 1155.245445807226 - ], - "median_throughput": 1043.0911784519503, - "std_throughput": 142.24286502401756, + 813.6298872283359, + 811.5786299565627, + 801.7671484233234, + 819.8315613702307, + 830.8606718884582 + ], + "median_throughput": 813.6298872283359, + "std_throughput": 10.749101171567563, "times": [ - 1.2297247499227524, - 1.127739500021562, - 1.403484582901001, - 0.8977782079018652, - 0.9432133338414133, - 0.9511985001154244, - 1.1059956250246614, - 1.1191250830888748, - 1.0726188330445439, - 0.9662983331363648, - 0.9378050840459764, - 0.9263818750623614, - 0.8745308339130133, - 1.0542036248371005, - 1.4694175000768155, - 1.075309457955882, - 0.8819269170053303, - 0.8725577080622315, - 0.9232231248170137, - 0.865616915980354 - ], - "mean_time": 0.9586889628230757, - "std_time": 0.130733216382138, + 2.4581201248802245, + 2.464333000127226, + 2.4944898327812552, + 2.43952550040558, + 2.4071424580179155 + ], + "mean_time": 2.4581201248802245, + "std_time": 0.03247494017730034, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "MedianBlur(blur_limit=5, p=1.0)": { + "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))": { + "supported": false + }, + "Erasing(scale=(0.02, 0.33), ratio=(0.3, 3.3), fill=0)": { + "supported": false + }, + "JpegCompression(quality=50)": { "supported": true, - "warmup_iterations": 16, + "warmup_iterations": 28, "throughputs": [ - 871.1906508520815, - 827.0109777283358, - 857.988926451302, - 800.7038187586309, - 821.6193238929377, - 766.4387708019078, - 853.0985307784908, - 783.8887857006174, - 790.604691116027, - 846.5622499362712, - 845.8925466309306, - 816.3941474541554, - 861.2383531008277, - 865.0617554756707, - 856.7648708625062, - 867.8653025129299, - 850.961684739552, - 868.4932573087439, - 873.8532082195351, - 847.8611401040373 - ], - "median_throughput": 849.4114124217947, - "std_throughput": 31.949672566345548, + 710.883522957997, + 686.7234161194074, + 704.212437467886, + 672.8538853097876, + 645.8282469585869 + ], + "median_throughput": 686.7234161194074, + "std_throughput": 26.07657824135371, "times": [ - 1.147854374954477, - 1.2091737920418382, - 1.1655162079259753, - 1.2489012498408556, - 1.21710866689682, - 1.3047356659080833, - 1.1721975409891456, - 1.2756911672186106, - 1.2648546248674393, - 1.1812480418011546, - 1.182183250086382, - 1.224898540880531, - 1.1611187499947846, - 1.1559868340846151, - 1.1671813749708235, - 1.152252540923655, - 1.1751410409342498, - 1.151419417001307, - 1.1443569590337574, - 1.179438415914774 - ], - "mean_time": 1.1772858068257588, - "std_time": 0.04428230595330274, + 2.813400417100638, + 2.9123806660063565, + 2.840052083134651, + 2.9724135412834585, + 3.096798582933843 + ], + "mean_time": 2.9123806660063565, + "std_time": 0.11059026170226777, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "MotionBlur(kernel_size=5, angle=45, direction=0.0, p=1.0)": { + "RandomGamma(gamma=120)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 670.8377497213378, - 667.2207195788003, - 660.384429570762, - 667.3749553130407, - 678.3428694897254, - 657.41272438562, - 674.5897798247232, - 665.1047604357523, - 677.7094335737195, - 634.124121544672, - 666.006801847919, - 652.1161796299843, - 657.417802788998, - 654.4833860352944, - 521.926524771135, - 588.7584956959106, - 637.0605516234338, - 662.6703961645563, - 672.8161692088397, - 662.3393279009848 - ], - "median_throughput": 662.5048620327706, - "std_throughput": 36.49095799396928, + 3373.338793926833, + 3451.9872438559846, + 3554.0570584365505, + 3503.9514393894638, + 3528.4746428371286 + ], + "median_throughput": 3503.9514393894638, + "std_throughput": 71.66126289694787, "times": [ - 1.4906734160613269, - 1.4987544161267579, - 1.5142695000395179, - 1.4984080418944359, - 1.4741807498503476, - 1.521114458097145, - 1.4823823750484735, - 1.5035225418396294, - 1.4755586250685155, - 1.5769783328287303, - 1.501486166846007, - 1.5334690830204636, - 1.5211027078330517, - 1.527922665933147, - 1.9159784999210387, - 1.6984892911277711, - 1.5697095000650734, - 1.509045833023265, - 1.486290083033964, - 1.509800124913454 - ], - "mean_time": 1.509422884734294, - "std_time": 0.08313944581926785, + 0.5928844157606363, + 0.579376416746527, + 0.5627371668815613, + 0.5707841659896076, + 0.566817166749388 + ], + "mean_time": 0.5707841659896076, + "std_time": 0.011673424955776057, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Posterize(bits=4, p=1.0)": { + "PlankianJitter(mode=blackbody)": { + "supported": false + }, + "MedianBlur(blur_limit=5)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 2609.3797665210545, - 2367.547551605153, - 2414.1371852855373, - 2402.388457913028, - 2206.439841930576, - 2241.4124484104336, - 2343.12074431921, - 2329.8466844405107, - 2385.736868343803, - 2427.2539369115334, - 2220.59995139367, - 2422.1708609684856, - 2728.064790552168, - 2509.237387274668, - 2342.670632315165, - 2490.348344351137, - 2396.7320544531894, - 2641.199635982728, - 2630.4866584853235, - 2368.8765149260607 - ], - "median_throughput": 2399.560256183109, - "std_throughput": 141.67699586899403, + 1124.6715514763257, + 1144.9700214628517, + 1152.0990904051016, + 1153.000970812465, + 1162.4353777021936 + ], + "median_throughput": 1152.0990904051016, + "std_throughput": 14.159765258203405, "times": [ - 0.38323283288627863, - 0.42237800010479987, - 0.4142266670241952, - 0.4162524160929024, - 0.45321879209950566, - 0.4461472500115633, - 0.42678124993108213, - 0.42921279184520245, - 0.41915770899504423, - 0.4119882080703974, - 0.4503287498373538, - 0.4128527909051627, - 0.3665602090768516, - 0.3985274590086192, - 0.4268632500898093, - 0.4015502498950809, - 0.41723479190841317, - 0.37861583288758993, - 0.38015779200941324, - 0.4221410418394953 - ], - "mean_time": 0.4167430250702113, - "std_time": 0.024605716688782697, + 1.7782969591207802, + 1.7467706250026822, + 1.7359617906622589, + 1.734603916760534, + 1.7205257499590516 + ], + "mean_time": 1.735961790662259, + "std_time": 0.02133567473293023, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "JpegCompression(quality=50, p=1.0)": { + "MotionBlur(kernel_size=5, angle_range=(0, 360), direction_range=(-1, 1))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 473.83513021122894, - 430.6699062079495, - 472.2493676658715, - 476.54431033264063, - 456.26670345165354, - 460.4608237257955, - 426.49924386669187, - 358.19362234635025, - 335.3949408579424, - 366.75221819766574, - 395.9653898412258, - 216.9070417040135, - 312.04258944585393, - 350.58246273866797, - 323.94081778601816, - 495.9948724026886, - 493.12498510653614, - 504.6839083141943, - 486.5122191392196, - 485.4353416863566 - ], - "median_throughput": 443.4683048298015, - "std_throughput": 79.4614787650676, + 929.4528626531693, + 938.8847268556485, + 927.9316652488782, + 864.724934931641, + 864.4812840777104 + ], + "median_throughput": 927.9316652488782, + "std_throughput": 37.20141283706308, "times": [ - 2.1104387079831213, - 2.32196395797655, - 2.1175253340043128, - 2.0984407500363886, - 2.1917005830910057, - 2.171737417113036, - 2.3446700419299304, - 2.7917861670721322, - 2.9815595829859376, - 2.726636542007327, - 2.5254732500761747, - 4.610269874799997, - 3.2046907499898225, - 2.8523959589656442, - 3.086983625078574, - 2.0161498750094324, - 2.0278834579512477, - 1.9814382498152554, - 2.055446832906455, - 2.0600065840408206 - ], - "mean_time": 2.2549525842298683, - "std_time": 0.404046613786264, + 2.151803582906723, + 2.130186957772821, + 2.1553311250172555, + 2.312874209135771, + 2.3135260841809213 + ], + "mean_time": 2.1553311250172555, + "std_time": 0.08640869364107034, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianNoise(mean=127, var=0.01, per_channel=True, p=1.0)": { + "CLAHE(clip_limit=(1, 4), tile_grid_size=(8, 8))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 197.1848057001005, - 172.6055675586084, - 191.767504157589, - 162.04781771841064, - 193.7190707901989, - 209.40172199241118, - 190.80058781773815, - 208.68766943088843, - 227.60800721658987, - 221.8762103560513, - 216.2180589580602, - 228.12909715973709, - 216.54125443002172, - 213.2269113392473, - 191.24571160046844, - 203.90973986039407, - 174.67476724054276, - 203.61050632339897, - 220.26065624222778, - 198.1975550885994 - ], - "median_throughput": 203.7601230918965, - "std_throughput": 18.311840051759827, + 538.623139251688, + 554.7656179663326, + 561.994964098679, + 563.4941049770804, + 532.47282174052 + ], + "median_throughput": 554.7656179663326, + "std_throughput": 14.008490600932484, "times": [ - 5.071384666021913, - 5.793555875075981, - 5.214647833025083, - 6.171017999993637, - 5.162114374805242, - 4.775509916944429, - 5.24107400001958, - 4.7918499580118805, - 4.393518541939557, - 4.507017667172477, - 4.624960582936183, - 4.383482915814966, - 4.6180576658807695, - 4.689839540980756, - 5.228875417029485, - 4.904130625072867, - 5.724925332935527, - 4.911337916972116, - 4.540075459051877, - 5.045470916898921 - ], - "mean_time": 4.907731624941141, - "std_time": 0.4410558610251429, + 3.7131713330745697, + 3.60512608429417, + 3.5587507500313222, + 3.549282915890217, + 3.7560602501034737 + ], + "mean_time": 3.60512608429417, + "std_time": 0.09103371447593257, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True, p=1.0)": { + "Brightness(brightness_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 256.19991247644475, - 263.55424912434245, - 264.63680827830797, - 265.48470510588106, - 266.2791358623671, - 265.39495011211744, - 251.46375745357946, - 222.37517927701808, - 183.53488652614894, - 228.93137196152495, - 252.68512958549172, - 240.84430379177294, - 249.23082438505335, - 199.47826125265686, - 230.73944543356953, - 254.80093534278262, - 243.4262833259242, - 248.1887366480074, - 253.20769842871158, - 251.46851324926283 - ], - "median_throughput": 251.46613535142114, - "std_throughput": 22.145426751383148, + 1075.8805796458748, + 1038.5933721669198, + 1108.4349586630126, + 1120.4200381577537, + 1072.5596428625588 + ], + "median_throughput": 1075.8805796458748, + "std_throughput": 32.32133296210586, "times": [ - 3.903201957931742, - 3.7942852498963475, - 3.77876383299008, - 3.766695334110409, - 3.7554575831163675, - 3.7679692080710083, - 3.9767162080388516, - 4.496904750121757, - 5.448555415961891, - 4.368121290812269, - 3.957494458183646, - 4.152059999993071, - 4.012344791088253, - 5.013077584095299, - 4.333892707945779, - 3.9246323748957366, - 4.108019833918661, - 4.029191709123552, - 3.949326999951154, - 3.976641000015661 - ], - "mean_time": 3.9766786036716675, - "std_time": 0.35020717445048144, + 1.8589423750527203, + 1.92568145878613, + 1.804345834068954, + 1.785044833086431, + 1.8646981669589877 + ], + "mean_time": 1.8589423750527203, + "std_time": 0.055845877877285684, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)": { - "supported": false - }, - "Clahe(clip_limit=(1, 4), tile_grid_size=(8, 8), p=1.0)": { + "Contrast(contrast_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 409.895008963993, - 422.6299681323419, - 405.12039770734765, - 373.31056546747834, - 424.79308388423544, - 413.81005550703054, - 422.4325483373865, - 428.2338351318377, - 422.11868850817683, - 421.94226354136623, - 423.83656862676935, - 417.40180846041056, - 426.5002899702718, - 413.3624298222498, - 422.27141054473896, - 412.33401700769997, - 419.9657822221248, - 424.12926529780316, - 423.6970962515612, - 423.8800378121953 - ], - "median_throughput": 422.19504952645786, - "std_throughput": 12.039992181242159, + 716.329385227429, + 713.1190749014858, + 716.5529110850094, + 725.40078647961, + 722.6922164146862 + ], + "median_throughput": 716.5529110850094, + "std_throughput": 5.053320823847988, "times": [ - 2.439649125095457, - 2.3661360419355333, - 2.468402000144124, - 2.6787347921635956, - 2.3540872908197343, - 2.416567665990442, - 2.367241832893342, - 2.3351727910339832, - 2.3690019589848816, - 2.3699924999382347, - 2.3593999999575317, - 2.395773041062057, - 2.344664291013032, - 2.41918454086408, - 2.3681451668962836, - 2.425218290882185, - 2.381146375089884, - 2.3577717498410493, - 2.3601766659412533, - 2.3591580418869853 - ], - "mean_time": 2.368573485458011, - "std_time": 0.06754604602208823, + 2.792011665645987, + 2.8045807080343366, + 2.79114070860669, + 2.757096542045474, + 2.7674298333004117 + ], + "mean_time": 2.79114070860669, + "std_time": 0.01968386318288044, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Brightness(brightness_limit=(0.2, 0.2), p=1.0)": { + "CoarseDropout(hole_height_range=(0.1, 0.1), hole_width_range=(0.1, 0.1), num_holes_range=(4, 4))": { "supported": true, - "warmup_iterations": 21, + "warmup_iterations": 19, "throughputs": [ - 723.5106691819041, - 751.8645771670815, - 693.9797431293288, - 785.2509714197083, - 702.4835309198019, - 727.0605360750681, - 792.6997633296459, - 789.8301988262405, - 745.4743416421054, - 738.8693948264613, - 688.0040021806711, - 728.0854692339782, - 745.8224850861413, - 755.2919531826226, - 723.2629135533309, - 640.9645920134444, - 758.6483784152414, - 757.8692165347029, - 796.246123774138, - 712.9416918660814 - ], - "median_throughput": 742.1718682342834, - "std_throughput": 39.14978378270765, + 1190.0629149547021, + 1200.9542786575405, + 1148.1085912908477, + 1169.3380272979236, + 1193.6629622212095 + ], + "median_throughput": 1190.0629149547021, + "std_throughput": 21.545623485797723, "times": [ - 1.38214962487109, - 1.3300267499871552, - 1.440964249894023, - 1.2734782081097364, - 1.4235209168400615, - 1.375401291064918, - 1.2615116671659052, - 1.2660949169658124, - 1.3414277918636799, - 1.3534191658254713, - 1.4534799170214683, - 1.3734651249833405, - 1.340801625046879, - 1.3239913331344724, - 1.3826230838894844, - 1.5601485830266029, - 1.3181337078567594, - 1.3194888751022518, - 1.2558930839877576, - 1.4026392500381917 - ], - "mean_time": 1.3473967995837959, - "std_time": 0.0710755764681801, + 1.6805834169499576, + 1.6653423327952623, + 1.7419955004006624, + 1.7103694169782102, + 1.6755148340016603 + ], + "mean_time": 1.6805834169499576, + "std_time": 0.030426305267614726, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Contrast(contrast_limit=(0.2, 0.2), p=1.0)": { + "Blur(radius=5, border_mode=constant)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 515.0459513820163, - 508.4484320532241, - 500.4080828113525, - 514.6175396275573, - 517.3942334856164, - 509.77776049961557, - 526.7694926984328, - 516.8852632729596, - 511.47641184120374, - 509.0061859418022, - 500.9050728496612, - 490.41795866782036, - 505.362740858865, - 497.7789414327062, - 526.2278539984809, - 520.577258387195, - 501.35796991896444, - 511.1732787079466, - 506.249299559127, - 516.7633730729013 - ], - "median_throughput": 510.4755196037811, - "std_throughput": 9.385401972349491, + 5410.364912631314, + 5380.896264867456, + 5569.602676523225, + 5239.906378715559, + 5302.7019871236225 + ], + "median_throughput": 5380.896264867456, + "std_throughput": 124.97079700040217, "times": [ - 1.9415743339341134, - 1.9667677918914706, - 1.9983689999207854, - 1.943190666846931, - 1.9327621671836823, - 1.9616391249001026, - 1.8983635420445353, - 1.9346653330139816, - 1.9551243749447167, - 1.9646126660518348, - 1.9963862500153482, - 2.039077040972188, - 1.9787766670342535, - 2.008923875167966, - 1.9003175001125783, - 1.9209444590378553, - 1.9945828330237418, - 1.9562837919220328, - 1.9753113749902695, - 1.9351216671057045 - ], - "mean_time": 1.9589577983605877, - "std_time": 0.03601662700447094, + 0.3696608329191804, + 0.3716852921061218, + 0.3590920423157513, + 0.38168620876967907, + 0.3771662078797817 + ], + "mean_time": 0.3716852921061218, + "std_time": 0.008632355076440688, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "CoarseDropout(hole_height_range=(16, 16), hole_width_range=(16, 16), num_holes_range=(1, 1), p=1.0)": { + "HSV(hue=0.015, saturation=0.7, value=0.4)": { + "supported": false + }, + "ChannelDropout()": { + "supported": false + }, + "LinearIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "CornerIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "GaussianIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "Hue(hue=20)": { + "supported": false + }, + "PlasmaBrightness(roughness=0.5)": { + "supported": false + }, + "PlasmaContrast(roughness=0.5)": { + "supported": false + }, + "PlasmaShadow(roughness=0.5)": { + "supported": false + }, + "Rain(drop_width=5, drop_height=20)": { + "supported": false + }, + "SaltAndPepper(amount=(0.01, 0.06), salt_vs_pepper=(0.4, 0.6))": { + "supported": false + }, + "Saturation(saturation_factor=0.5)": { "supported": true, - "warmup_iterations": 24, + "warmup_iterations": 20, "throughputs": [ - 624.2552989630692, - 677.6610201111757, - 670.5060774996252, - 690.6949064557821, - 694.9695122741031, - 718.3954923329285, - 718.6857605496845, - 683.0367619466206, - 738.1068839998785, - 592.974131288875, - 530.9913547765179, - 540.8539557786319, - 606.4553228374768, - 682.2252105717728, - 620.4056380579053, - 583.4018243914021, - 488.4245716222362, - 656.9454252522706, - 408.24859477922047, - 648.8087819259746 - ], - "median_throughput": 652.8771035891226, - "std_throughput": 84.90350101222614, + 494.79401451226363, + 492.68746599391733, + 499.43315893273706, + 499.0212737420179, + 494.9602630319581 + ], + "median_throughput": 494.9602630319581, + "std_throughput": 2.9267039661334704, "times": [ - 1.601908708922565, - 1.4756640419363976, - 1.4914107918739319, - 1.4478172499220818, - 1.4389120419509709, - 1.3919909168034792, - 1.3914287090301514, - 1.4640500419773161, - 1.3548173329327255, - 1.6864142080303282, - 1.8832698329351842, - 1.8489279579371214, - 1.6489260829985142, - 1.4657916249707341, - 1.6118486658670008, - 1.7140844580717385, - 2.0473990419413894, - 1.5221964588854462, - 2.4494879168923944, - 1.5412861660588533 - ], - "mean_time": 1.5316818349159529, - "std_time": 0.1991877943127207, + 4.0420860829763114, + 4.059368540998548, + 4.00453987531364, + 4.007845166604966, + 4.040728416759521 + ], + "mean_time": 4.040728416759521, + "std_time": 0.023892859218548494, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Blur(radius=5, p=1.0)": { + "Snow(snow_point_range=(0.5, 0.5))": { + "supported": false + }, + "OpticalDistortion(distort_limit=0.5)": { + "supported": false + }, + "Shear(shear=10)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 3205.584127976634, - 2914.2917689244246, - 3500.8213800517883, - 3698.9048255180023, - 3941.5190231302313, - 3999.6566843632877, - 3947.2879146790906, - 4071.8518977291365, - 4009.8086660553267, - 3746.730980461005, - 4078.2604638622183, - 3687.944571579371, - 3885.9845759981026, - 3849.473394886233, - 2696.318380805882, - 3531.174231944559, - 3584.313435489876, - 4103.708930658076, - 3863.949682574971, - 3883.825715485313 - ], - "median_throughput": 3856.711538730602, - "std_throughput": 385.1328460434264, + 1229.1511007588956, + 1258.9243643295654, + 1244.39771533353, + 1255.4906135025917, + 1231.1267310857158 + ], + "median_throughput": 1244.39771533353, + "std_throughput": 13.610423019276789, "times": [ - 0.31195562495850027, - 0.34313654201105237, - 0.28564725001342595, - 0.2703502920921892, - 0.2537092918064445, - 0.250021459069103, - 0.2533385001588613, - 0.2455885000526905, - 0.249388457974419, - 0.2668993331026286, - 0.24520258302800357, - 0.27115374989807606, - 0.2573350409511477, - 0.25977579201571643, - 0.370876083150506, - 0.2831919169984758, - 0.27899345802143216, - 0.24368200008757412, - 0.2588025419972837, - 0.2574780830182135 - ], - "mean_time": 0.2592882537253849, - "std_time": 0.025892634722625797, + 1.627139249816537, + 1.58865779126063, + 1.6072032079100609, + 1.5930027500726283, + 1.6245281249284744 + ], + "mean_time": 1.6072032079100609, + "std_time": 0.01757855649207104, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "HSV(hue=0.015, saturation=0.7, value=0.4, p=1.0)": { + "ThinPlateSpline(num_control_points=4, distortion_scale=0.5)": { "supported": false } } diff --git a/output/kornia_results.json b/output/kornia_results.json index 158b0c1..fdf78d1 100644 --- a/output/kornia_results.json +++ b/output/kornia_results.json @@ -1,16 +1,16 @@ { "metadata": { "system_info": { - "python_version": "3.12.7 | packaged by Anaconda, Inc. | (main, Oct 4 2024, 08:22:19) [Clang 14.0.6 ]", - "platform": "macOS-15.0.1-arm64-arm-64bit", + "python_version": "3.12.8 | packaged by Anaconda, Inc. | (main, Dec 11 2024, 10:37:40) [Clang 14.0.6 ]", + "platform": "macOS-15.1-arm64-arm-64bit", "processor": "arm", - "cpu_count": "10", - "timestamp": "2024-11-02T17:20:07.232589+00:00" + "cpu_count": "16", + "timestamp": "2025-01-24T00:15:32.941638+00:00" }, "library_versions": { - "kornia": "0.7.3", - "numpy": "2.1.2", - "pillow": "11.0.0", + "kornia": "0.8.0", + "numpy": "2.2.2", + "pillow": "11.1.0", "opencv-python-headless": "not installed", "torch": "2.5.1", "opencv-python": "not installed" @@ -22,8 +22,8 @@ "pillow": "{'threads': 'unknown', 'simd': False}" }, "benchmark_params": { - "num_images": 1000, - "num_runs": 20, + "num_images": 2000, + "num_runs": 5, "max_warmup_iterations": 1000, "warmup_window": 5, "warmup_threshold": 0.05, @@ -31,1305 +31,1165 @@ } }, "results": { - "HorizontalFlip(p=1.0)": { + "Resize(target_size=512, interpolation=bilinear)": { "supported": true, - "warmup_iterations": 31, + "warmup_iterations": 16, + "throughputs": [ + 644.7656953409474, + 663.3667305599287, + 640.9704206198182, + 634.6939585353954, + 663.0867441529274 + ], + "median_throughput": 644.7656953409474, + "std_throughput": 13.14530391092543, + "times": [ + 3.1019020001403987, + 3.0149235827848315, + 3.120268791913986, + 3.151124999858439, + 3.0161966253072023 + ], + "mean_time": 3.101902000140399, + "std_time": 0.06324071641589311, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "RandomCrop128(height=128, width=128)": { + "supported": true, + "warmup_iterations": 16, "throughputs": [ - 448.90339368568414, - 582.5339005238167, - 426.21103374890384, - 384.7583186333275, - 437.2840397592497, - 633.3908620162621, - 482.47101390846115, - 612.4119366317673, - 497.3432235674168, - 661.7584224897213, - 614.088447779998, - 544.4787654187323, - 656.7029325460327, - 619.0276406680366, - 545.8733791418315, - 649.7195267877577, - 524.4746306352084, - 617.9378715500508, - 605.4939495827058, - 559.0303299951007 - ], - "median_throughput": 570.7821152594587, - "std_throughput": 84.42443071446293, + 2925.6031890083214, + 2926.465427171909, + 2945.8886283954366, + 3015.9263512901225, + 2999.29947492858 + ], + "median_throughput": 2945.8886283954366, + "std_throughput": 42.2619385999278, "times": [ - 2.22765079094097, - 1.7166382919531316, - 2.3462555420119315, - 2.5990341249853373, - 2.2868431250099093, - 1.578803958138451, - 2.0726633749436587, - 1.6328878328204155, - 2.010683875065297, - 1.5111254591029137, - 1.6284299169201404, - 1.836618916131556, - 1.522758541861549, - 1.61543674999848, - 1.831926666898653, - 1.5391256669536233, - 1.9066699161194265, - 1.6182856659870595, - 1.6515441660303622, - 1.7888117090333253 - ], - "mean_time": 1.7519820142672708, - "std_time": 0.2591358072059728, + 0.6836197087541223, + 0.6834182906895876, + 0.6789122917689383, + 0.663146167062223, + 0.6668223752640188 + ], + "mean_time": 0.6789122917689383, + "std_time": 0.009739726516783884, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "VerticalFlip(p=1.0)": { + "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear)": { "supported": true, - "warmup_iterations": 17, + "warmup_iterations": 16, "throughputs": [ - 1333.8192882378512, - 1301.6779707232533, - 1583.4321289138873, - 1508.9048020415003, - 1656.4322156562291, - 1630.0873912862626, - 1612.0498587014215, - 1587.858494526367, - 1482.1376467903867, - 1571.510298113317, - 1640.736647726363, - 1627.7654460331044, - 1644.6339389462164, - 1666.9715835128625, - 1591.2530933806665, - 1641.7392500628682, - 1493.0440013811615, - 1589.196640820623, - 1630.2880365148492, - 1559.7159677564389 - ], - "median_throughput": 1590.2248671006448, - "std_throughput": 100.37184406286515, + 660.8593649632422, + 644.0930827322514, + 628.4053021936505, + 660.7794702014885, + 667.5635382966091 + ], + "median_throughput": 660.7794702014885, + "std_throughput": 15.940841871701629, "times": [ - 0.7497267499566078, - 0.7682391670532525, - 0.6315395410638303, - 0.6627323331777006, - 0.6037071668542922, - 0.6134640420787036, - 0.6203282079659402, - 0.6297790410462767, - 0.6747011670377105, - 0.6363305421546102, - 0.6094823330640793, - 0.6143391251098365, - 0.6080380419734865, - 0.5998902500141412, - 0.6284355418756604, - 0.6091101251076907, - 0.6697726249694824, - 0.6292487501632422, - 0.6133885409217328, - 0.6411423750687391 - ], - "mean_time": 0.6288418831125663, - "std_time": 0.03969125419793744, + 3.026362500153482, + 3.105141249950975, + 3.1826593331061304, + 3.0267284172587097, + 2.995969499927014 + ], + "mean_time": 3.0267284172587097, + "std_time": 0.07301770297644782, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Rotate(angle=45, p=1.0, interpolation=nearest, mode=reflect)": { + "HorizontalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 169.18501379334677, - 172.81314915510623, - 189.11317827920212, - 167.64005352158242, - 167.36758467808872, - 174.86363259798256, - 156.20285236262816, - 160.98850916642493, - 161.45900057345102, - 156.30007707915294, - 149.30521751322766, - 162.0415397668111, - 180.12345751758141, - 166.67417047645256, - 164.89972037489636, - 159.04951267927896, - 165.5322831178411, - 188.62377771847278, - 171.96316313215365, - 188.36420171743455 - ], - "median_throughput": 167.02087757727065, - "std_throughput": 11.153124923680892, + 1283.84482508159, + 1296.8850978758257, + 1301.2028397006554, + 1302.862704918969, + 1273.0037405817716 + ], + "median_throughput": 1296.8850978758257, + "std_throughput": 12.776451491492057, "times": [ - 5.910689000040293, - 5.786596707999706, - 5.28783879103139, - 5.9651615410111845, - 5.974872624967247, - 5.718741999939084, - 6.401931750122458, - 6.211623457958922, - 6.193522791843861, - 6.3979495000094175, - 6.69768958282657, - 6.171257082838565, - 5.551747750025243, - 5.999729875009507, - 6.064291666029021, - 6.287350292084739, - 6.041117666987702, - 5.301558542065322, - 5.815198916941881, - 5.308864374877885 - ], - "mean_time": 5.98727545026435, - "std_time": 0.39981128118784054, + 1.5578206656500697, + 1.542156666982919, + 1.537039375398308, + 1.535081165842712, + 1.5710872923955321 + ], + "mean_time": 1.542156666982919, + "std_time": 0.015192779900286037, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Affine(angle=25.0, shift=(50, 50), scale=2.0, shear=[10.0, 15.0], p=1.0, interpolation=bilinear, mode=reflect)": { + "VerticalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 161.6525187380257, - 176.73343371325092, - 182.51605825213016, - 180.21642641609188, - 178.9242314611872, - 182.3429191557247, - 185.2092566577304, - 184.82481674161116, - 183.12657961289753, - 176.50189007762856, - 180.26090513890537, - 166.28748499627946, - 182.14801185800388, - 184.5483893149201, - 177.2574156493185, - 180.6655928221952, - 182.33280232427873, - 184.77442565235688, - 178.1114015192512, - 182.45058320907665 - ], - "median_throughput": 181.40680234009955, - "std_throughput": 6.0165338295916655, + 2871.8061629027006, + 2824.2220122797003, + 2800.25027164949, + 2883.6660586390904, + 2878.9648965733804 + ], + "median_throughput": 2871.8061629027006, + "std_throughput": 37.32138164389234, "times": [ - 6.186108374968171, - 5.658238959033042, - 5.478969957912341, - 5.548883749870583, - 5.58895791717805, - 5.484172374941409, - 5.399298167089, - 5.410528832813725, - 5.460703749908134, - 5.665661707986146, - 5.5475145829841495, - 6.01368166715838, - 5.490040708100423, - 5.418633040972054, - 5.641512916889042, - 5.535088249947876, - 5.484476667130366, - 5.41200437489897, - 5.614463709061965, - 5.480936165899038 - ], - "mean_time": 5.512472449215055, - "std_time": 0.18282653432816254, + 0.696425833273679, + 0.7081596245989203, + 0.7142218751832843, + 0.6935615842230618, + 0.6946941250935197 + ], + "mean_time": 0.696425833273679, + "std_time": 0.00905060189856321, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Equalize(p=1.0)": { + "Pad(padding=10, fill=0, border_mode=constant)": { + "supported": false + }, + "Rotate(angle=45, interpolation=nearest, mode=constant, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 184.45298512608164, - 179.4629736395413, - 170.08004802381163, - 183.9997032101173, - 191.1989635224967, - 163.6177331638272, - 171.15927066865146, - 194.10481988886065, - 173.63691048062108, - 186.10078813829804, - 190.39871781642094, - 187.04494886377356, - 181.47556967413055, - 170.2030257627126, - 190.29377272344956, - 185.09469016263316, - 176.35515600735232, - 193.4023293647398, - 176.96879574360807, - 193.76481301121308 - ], - "median_throughput": 184.22634416809947, - "std_throughput": 9.092721994113337, + 256.32680097434985, + 255.5175365430951, + 257.84906800402086, + 256.8825209177794, + 251.56144845552927 + ], + "median_throughput": 256.32680097434985, + "std_throughput": 2.426125041825789, "times": [ - 5.421435707947239, - 5.572180042043328, - 5.879584416979924, - 5.434791374951601, - 5.230153875192627, - 6.1118069579824805, - 5.8425114578567445, - 5.151855582837015, - 5.759144166018814, - 5.373432375025004, - 5.252136209048331, - 5.3463085000403225, - 5.51038358383812, - 5.875336208147928, - 5.255032709101215, - 5.4026401250157505, - 5.670375749934465, - 5.170568541157991, - 5.650713708018884, - 5.160895750159398 - ], - "mean_time": 5.428105326171692, - "std_time": 0.26791093808282607, + 7.802539540920407, + 7.827251417096704, + 7.756475582718849, + 7.785660125315189, + 7.950343791861087 + ], + "mean_time": 7.802539540920407, + "std_time": 0.07385078929751547, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomCrop80(height=80, width=80, p=1.0)": { + "Affine(angle=25.0, shift=(20, 20), scale=2.0, shear=(10.0, 15.0), interpolation=bilinear, mode=constant, fill=0)": { "supported": true, - "warmup_iterations": 18, + "warmup_iterations": 16, "throughputs": [ - 1461.8730705600462, - 1481.8141585703654, - 1466.9560800757356, - 1475.6564643050335, - 1482.0434677487153, - 1508.2023584776662, - 1510.345583823351, - 1447.1864683378303, - 1477.1951530972517, - 1491.5295111058422, - 1435.6886827992473, - 1491.6987891454617, - 1492.850832558665, - 1492.6168630352147, - 1507.457770294344, - 1488.0498435843292, - 1501.0404096100176, - 1498.5311584051944, - 1510.665486825241, - 1517.2958447925737 - ], - "median_throughput": 1491.614150125652, - "std_throughput": 21.591696278819782, + 240.6435265327651, + 251.47925071405578, + 251.1661447960612, + 248.41935036819268, + 239.97075596100476 + ], + "median_throughput": 248.41935036819268, + "std_throughput": 5.63569563313897, "times": [ - 0.6840539169497788, - 0.6748484580311924, - 0.6816836670041084, - 0.6776644999627024, - 0.6747440421022475, - 0.6630410000216216, - 0.6621001251041889, - 0.6909959579352289, - 0.6769586252048612, - 0.6704527081456035, - 0.6965298340655863, - 0.6703766251448542, - 0.6698592908214778, - 0.6699642920866609, - 0.6633685000706464, - 0.6720205000601709, - 0.6662045828998089, - 0.6673201250378042, - 0.661959916818887, - 0.6590672500897199 - ], - "mean_time": 0.6704146644866308, - "std_time": 0.009704513607116699, + 8.311048415955156, + 7.952942417003214, + 7.962856624741107, + 8.050902625080198, + 8.33434887509793 + ], + "mean_time": 8.050902625080198, + "std_time": 0.18264453513682877, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear, p=1.0)": { + "Perspective(scale=(0.05, 0.1), interpolation=bilinear, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 322.37306976803745, - 296.70557055058055, - 304.4296376610489, - 302.9430845274185, - 328.4189496776167, - 324.41588854244134, - 306.34171775080847, - 316.5159736741713, - 318.10448319487705, - 324.0018854929, - 328.56278869329964, - 318.9028381964616, - 326.73444566539763, - 304.47756330477836, - 320.25195713564307, - 319.8936459558546, - 325.2775017173808, - 329.6541911350349, - 329.9608175736375, - 325.87214664708733 - ], - "median_throughput": 321.31251345184023, - "std_throughput": 10.187046603911316, + 154.49844877894185, + 152.9661718177519, + 159.00516036092952, + 160.6556840453454, + 154.4154966493015 + ], + "median_throughput": 154.49844877894185, + "std_throughput": 3.3241875149978792, "times": [ - 3.101996083976701, - 3.3703445410355926, - 3.2848312919959426, - 3.300950082950294, - 3.044891291996464, - 3.0824630830902606, - 3.2643285000231117, - 3.1593982079066336, - 3.1436212088447064, - 3.0864017920102924, - 3.043558292090893, - 3.1357513330876827, - 3.06058945809491, - 3.2843142501078546, - 3.122541416902095, - 3.1260389590170234, - 3.074298083083704, - 3.0334818330593407, - 3.030662874924019, - 3.0686881658621132 - ], - "mean_time": 3.1122348434459104, - "std_time": 0.09867179168312143, + 12.945113791152835, + 13.074786250013858, + 12.578208125196397, + 12.448983749840409, + 12.952067916747183 + ], + "mean_time": 12.945113791152835, + "std_time": 0.2785269754154475, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ShiftRGB(pixel_shift=100, p=1.0, per_channel=True)": { - "supported": false + "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True)": { + "supported": true, + "warmup_iterations": 9, + "throughputs": [], + "median_throughput": 1.3831325440910864, + "std_throughput": 0.046585282290123875, + "times": [], + "mean_time": 0.6887213625013828, + "std_time": 0.0, + "variance_stable": false, + "early_stopped": true, + "early_stop_reason": "Transform timeout: 65.4 sec > 60 sec limit" + }, + "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 107.30183559129244, + 105.3372677454116, + 99.27335934118732, + 97.52889692690357, + 103.72190945676807 + ], + "median_throughput": 103.72190945676807, + "std_throughput": 4.112051390739836, + "times": [ + 18.639010124839842, + 18.986632583197206, + 20.146391874644905, + 20.506742750294507, + 19.282329167239368 + ], + "mean_time": 19.282329167239368, + "std_time": 0.7644472501916144, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "ChannelShuffle()": { + "supported": true, + "warmup_iterations": 19, + "throughputs": [ + 1342.1933007547862, + 1394.949330437687, + 1327.547769542175, + 1278.525332187731, + 1306.046040344834 + ], + "median_throughput": 1327.547769542175, + "std_throughput": 43.57875100212765, + "times": [ + 1.4900983329862356, + 1.4337438330985606, + 1.506537124980241, + 1.5643022079020739, + 1.5313395839184523 + ], + "mean_time": 1.506537124980241, + "std_time": 0.04945434563730737, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Grayscale(num_output_channels=1)": { + "supported": true, + "warmup_iterations": 19, + "throughputs": [ + 1241.6737694777662, + 1282.9062445637646, + 1167.624033368525, + 1160.7703443509472, + 1200.5851047282176 + ], + "median_throughput": 1200.5851047282176, + "std_throughput": 51.53623958566827, + "times": [ + 1.610729041043669, + 1.5589603749103844, + 1.7128801248036325, + 1.722993708215654, + 1.6658544172532856 + ], + "mean_time": 1.6658544172532856, + "std_time": 0.07150836040219227, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "RGBShift(pixel_shift=100)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 897.398620856475, + 887.2161579412557, + 895.9063408650005, + 887.417091052965, + 910.2947395732891 + ], + "median_throughput": 895.9063408650005, + "std_throughput": 9.440633005414849, + "times": [ + 2.2286640000529587, + 2.254242083057761, + 2.232376208063215, + 2.2537316670641303, + 2.197090582922101 + ], + "mean_time": 2.232376208063215, + "std_time": 0.023523713974383093, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "GaussianBlur(sigma=2.0, kernel_size=(5, 5))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 251.96149793084138, + 254.1544281402825, + 255.97368047109893, + 258.2244583860759, + 245.10739844739888 + ], + "median_throughput": 254.1544281402825, + "std_throughput": 5.020123625058147, + "times": [ + 7.937720709014684, + 7.869231374934316, + 7.813303290866315, + 7.745199709199369, + 8.159688416868448 + ], + "mean_time": 7.869231374934316, + "std_time": 0.15543508183359978, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "Resize(target_size=512, interpolation=bilinear, p=1.0)": { + "GaussianNoise(mean=0, std=0.44, per_channel=True)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 272.1296975518267, - 275.39997000314276, - 332.703281166975, - 332.3197672445391, - 327.42055468230666, - 322.77246477654927, - 319.5565534686551, - 328.8152790035485, - 332.80127651063356, - 334.99101314520954, - 336.13851670414334, - 337.51408282733064, - 333.09927557724467, - 334.1363558802073, - 337.87974942105114, - 330.5041034261798, - 328.789638616184, - 332.5587531129312, - 335.5948417321734, - 331.3938141618272 - ], - "median_throughput": 332.43926017873514, - "std_throughput": 18.38326912117547, + 124.64705310527862, + 124.48139301108264, + 125.35794818730331, + 125.77558235456047, + 124.82963258982805 + ], + "median_throughput": 124.82963258982805, + "std_throughput": 0.5363129255690204, "times": [ - 3.6747183750849217, - 3.6310824579559267, - 3.005681207869202, - 3.009149916935712, - 3.0541759999468923, - 3.0981577089987695, - 3.1293365419842303, - 3.0412212079390883, - 3.0047961669042706, - 2.985154707916081, - 2.9749640410300344, - 2.9628393328748643, - 3.0021079999860376, - 2.9927901660557836, - 2.9596328330226243, - 3.0256810418795794, - 3.0414583750534803, - 3.006987459026277, - 2.9797835831996053, - 3.0175578338094056 - ], - "mean_time": 3.008068299340916, - "std_time": 0.16634054910340546, + 16.045305124949664, + 16.066658250056207, + 15.954313459340483, + 15.901337624993175, + 16.021836790721864 + ], + "mean_time": 16.021836790721864, + "std_time": 0.06883556399189145, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomGamma(gamma=120, p=1.0)": { + "Invert()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 117.73368714488889, - 136.14337881463436, - 130.9928219867886, - 128.6422065946435, - 136.4167753453396, - 127.65998052812725, - 118.0241221794838, - 100.77449990010722, - 117.25514269680114, - 112.01460849741979, - 114.05073230499691, - 125.2483158701366, - 138.29531548264913, - 127.70298329000659, - 136.30823016172639, - 120.68722929557723, - 127.94729663833166, - 133.43270139473339, - 138.54227904073596, - 136.39932029264054 - ], - "median_throughput": 127.82513996416913, - "std_throughput": 10.366667038641586, + 2881.425038649982, + 2813.240895310783, + 2816.4100253762836, + 2909.56260903906, + 2883.1772601322114 + ], + "median_throughput": 2881.425038649982, + "std_throughput": 43.40581047722923, "times": [ - 8.493745709070936, - 7.345197458053008, - 7.63400608394295, - 7.773498499998823, - 7.330476750154048, - 7.833308417117223, - 8.472844207892194, - 9.92314524995163, - 8.528410583967343, - 8.92740699998103, - 8.768027874873951, - 7.984139292035252, - 7.23090291605331, - 7.83067062520422, - 7.336314166896045, - 8.28588083293289, - 7.815718082943931, - 7.494414709042758, - 7.218013208126649, - 7.331414832966402 - ], - "mean_time": 7.823187209341697, - "std_time": 0.6344634318643296, + 0.6941009997390211, + 0.7109238328412175, + 0.7101238747127354, + 0.6873885421082377, + 0.693679166957736 + ], + "mean_time": 0.6941009997390211, + "std_time": 0.010455943167913538, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Grayscale(p=1.0, num_output_channels=3)": { + "Posterize(bits=4)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 654.7583405666858, - 536.2449647149244, - 630.324071673821, - 503.94801288564634, - 638.2722055553484, - 628.9066731344595, - 608.6808387837523, - 668.7185179881195, - 675.0260200504972, - 670.8184177804883, - 668.7739551370374, - 688.7255510293276, - 546.7492477179719, - 626.6162292308452, - 393.93324412032723, - 593.3419466738812, - 499.8985830738155, - 645.943489604318, - 599.1237667145969, - 572.4053674069161 - ], - "median_throughput": 627.7614511826523, - "std_throughput": 74.82154498648603, + 883.0192800123814, + 836.0568176221628, + 868.0846770285931, + 825.3826771407233, + 810.5405257453027 + ], + "median_throughput": 836.0568176221628, + "std_throughput": 30.12436294300012, "times": [ - 1.5272810410242528, - 1.8648193750996143, - 1.5864854999817908, - 1.9843316660262644, - 1.566729666898027, - 1.5900610419921577, - 1.6428971248678863, - 1.4953974999953061, - 1.4814243752043694, - 1.4907163749448955, - 1.4952735409606248, - 1.4519571671262383, - 1.828991999849677, - 1.5958731251303107, - 2.538501167204231, - 1.685368792153895, - 2.0004057500045747, - 1.5481230418663472, - 1.6691042077727616, - 1.7470136671327055 - ], - "mean_time": 1.5929617820847075, - "std_time": 0.18986170848092618, + 2.264956207945943, + 2.3921819161623716, + 2.303922708146274, + 2.4231184581294656, + 2.4674892080947757 + ], + "mean_time": 2.3921819161623716, + "std_time": 0.08619385040494222, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5, p=1.0)": { + "Solarize(threshold=0.5)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 55.33753961290841, - 54.857085429582575, - 54.318391325645734, - 56.0295473701349, - 57.01364102018888, - 55.89716122217025, - 52.07322290216098, - 51.80112568108011, - 45.08984088786324, - 51.31239302351242, - 46.210687344315296, - 46.25838378549288, - 46.967157451880205, - 47.92630305171997, - 48.008039809526366, - 49.74744971392355, - 48.83381174498719, - 47.88207812478373, - 48.62028948440098, - 49.65887374767807 - ], - "median_throughput": 49.703161730800815, - "std_throughput": 3.7598942003546085, + 263.65340703333305, + 262.7294973191033, + 250.54983945535403, + 262.3589742757356, + 267.05876678867526 + ], + "median_throughput": 262.7294973191033, + "std_throughput": 6.27352152849296, "times": [ - 18.07091545802541, - 18.229185750009492, - 18.40997083298862, - 17.84772583283484, - 17.539662124821916, - 17.889996166806668, - 19.203727832995355, - 19.30459979106672, - 22.177944750059396, - 19.488469375064597, - 21.64001570781693, - 21.61770295817405, - 21.291473750025034, - 20.865369042148814, - 20.82984441705048, - 20.101532957982272, - 20.47761508403346, - 20.884640750009567, - 20.567545166937634, - 20.13738783285953 - ], - "mean_time": 20.119444421184674, - "std_time": 1.5219752578977497, + 7.5857164999470115, + 7.612392290960997, + 7.982443749904633, + 7.623143082950264, + 7.488988375291228 + ], + "mean_time": 7.612392290960997, + "std_time": 0.18177063256309609, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "PlankianJitter(mode=blackbody, p=1.0)": { + "Sharpen(alpha=(0.2, 0.5), lightness=(0.5, 1))": { "supported": true, "warmup_iterations": 25, "throughputs": [ - 767.9932910284563, - 1059.827902788466, - 1006.2403676951285, - 1130.2961092949763, - 983.1218061571395, - 1050.2433346261394, - 1082.7851027922802, - 851.3096828950969, - 838.2234360185529, - 780.9842317641084, - 1092.496140977911, - 942.4468143579008, - 1003.4272478650787, - 1058.0183769618716, - 1061.0516290096923, - 1116.0230584311446, - 1119.2887591348865, - 1040.4003488895164, - 938.4683820062788, - 879.315326436931 - ], - "median_throughput": 1023.3203582923225, - "std_throughput": 113.55961072496743, + 199.10706621979256, + 203.35691769768866, + 200.55870978113705, + 201.12821109969983, + 200.1543148018568 + ], + "median_throughput": 200.55870978113705, + "std_throughput": 1.5786128378137139, + "times": [ + 10.044846915639937, + 9.834924833849072, + 9.97214233269915, + 9.943905875086784, + 9.992290208581835 + ], + "mean_time": 9.97214233269915, + "std_time": 0.07849148971931139, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "AutoContrast()": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 541.121368537491, + 529.2012593373198, + 533.4434182795068, + 544.3193118731957, + 547.9447801857098 + ], + "median_throughput": 541.121368537491, + "std_throughput": 7.737620078069171, + "times": [ + 3.696028499864042, + 3.779280500020832, + 3.749226124957204, + 3.674313874915242, + 3.6500028329901397 + ], + "mean_time": 3.696028499864042, + "std_time": 0.05285036960739146, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Equalize()": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 305.6838472429545, + 305.6862436968788, + 305.1848910218173, + 303.7513865982437, + 305.8766377119709 + ], + "median_throughput": 305.6838472429545, + "std_throughput": 0.8689635335259419, + "times": [ + 6.542707500047982, + 6.542656207922846, + 6.553404374979436, + 6.584332082886249, + 6.538583707995713 + ], + "mean_time": 6.542707500047981, + "std_time": 0.018598870301281233, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1220.824488564296, + 1251.5065010577162, + 1250.5806085975646, + 1256.71070404207, + 1240.9480593033768 + ], + "median_throughput": 1250.5806085975646, + "std_throughput": 14.208866727752334, + "times": [ + 1.638237124774605, + 1.598073999863118, + 1.599257166031748, + 1.591456166934222, + 1.6116710002534091 + ], + "mean_time": 1.599257166031748, + "std_time": 0.018170465605596507, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Erasing(scale=(0.02, 0.33), ratio=(0.3, 3.3), fill=0)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1210.3796101078265, + 1216.3328568697054, + 1207.063949175758, + 1215.4146173615584, + 1153.0780266858044 + ], + "median_throughput": 1210.3796101078265, + "std_throughput": 26.751869928740373, + "times": [ + 1.652374166995287, + 1.6442867498844862, + 1.6569130420684814, + 1.6455290000885725, + 1.7344879996962845 + ], + "mean_time": 1.652374166995287, + "std_time": 0.03652085545718233, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "JpegCompression(quality=50)": { + "supported": true, + "warmup_iterations": 24, + "throughputs": [ + 120.69854220528356, + 121.34229422018227, + 119.07365577896734, + 119.88419157305417, + 119.9445733129475 + ], + "median_throughput": 119.9445733129475, + "std_throughput": 0.8640551955164559, "times": [ - 1.3020947079639882, - 0.9435494171921164, - 0.9937983329873532, - 0.8847239159513265, - 1.0171679579652846, - 0.952160291839391, - 0.9235442909412086, - 1.1746606670785695, - 1.1929993329104036, - 1.2804355828557163, - 0.9153350410051644, - 1.0610678340308368, - 0.9965844580437988, - 0.9451631670817733, - 0.9424612079747021, - 0.8960388340055943, - 0.8934245000127703, - 0.9611684589181095, - 1.0655660000629723, - 1.137248459039256 - ], - "mean_time": 0.977211087316548, - "std_time": 0.10844278604695666, + 16.570208417251706, + 16.482299208641052, + 16.796326499897987, + 16.682766708079726, + 16.674368374980986 + ], + "mean_time": 16.674368374980986, + "std_time": 0.12011860335495786, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomPerspective(scale=(0.05, 0.1), p=1.0, interpolation=bilinear)": { + "RandomGamma(gamma=120)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 84.55781356656627, - 99.6840141347062, - 96.87501114007674, - 101.01496809492694, - 102.68224946809036, - 76.58828278628864, - 92.58239995598323, - 83.41565937658451, - 92.98439626821857, - 87.03234268202861, - 93.12302702725702, - 101.46500972697316, - 100.42192144752285, - 100.71462312571592, - 97.63154337615349, - 98.92765146489766, - 99.44688100232038, - 99.90487307945435, - 96.99111848715478, - 101.9811131486392 - ], - "median_throughput": 98.27959742052558, - "std_throughput": 7.252255797762909, + 230.46597299090132, + 229.68810543448026, + 231.558707913479, + 231.99395474224403, + 225.4597215459908 + ], + "median_throughput": 230.46597299090132, + "std_throughput": 2.607441583786888, "times": [ - 11.82622820790857, - 10.031698750099167, - 10.322579458123073, - 9.899523000000045, - 9.738781582796946, - 13.056827540975064, - 10.801189000019804, - 11.988156749866903, - 10.754492582986131, - 11.489981415914372, - 10.738482542103156, - 9.855614291969687, - 9.957985125016421, - 9.929044750053436, - 10.242591332877055, - 10.108397249830887, - 10.055619542021304, - 10.009521749801934, - 10.310222374973819, - 9.805737250018865 - ], - "mean_time": 10.175051854568864, - "std_time": 0.7508382282956308, + 8.67807066719979, + 8.707460041157901, + 8.637118500191718, + 8.620914291590452, + 8.870764082763344 + ], + "mean_time": 8.67807066719979, + "std_time": 0.09818179244009823, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianBlur(sigma=2.0, kernel_size=(5, 5), p=1.0)": { + "PlankianJitter(mode=blackbody)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 161.88898653922638, - 178.3798388118364, - 153.4374917849696, - 157.1389152033167, - 139.22948464460362, - 147.38731208753296, - 159.44698576161574, - 177.55685494266442, - 161.60218654806812, - 156.26046212576247, - 154.21475379995744, - 163.48203881257, - 167.17175640059713, - 181.65963560191662, - 176.67658921895685, - 180.80803334119358, - 170.6040360471316, - 177.67741634393053, - 179.3270947965701, - 175.62545914998685 - ], - "median_throughput": 165.32689760658357, - "std_throughput": 12.382498349524843, + 2048.380353829186, + 2159.841695221613, + 2183.160626450853, + 2149.940235286015, + 2137.391338159479 + ], + "median_throughput": 2149.940235286015, + "std_throughput": 51.637411011604186, "times": [ - 6.177072457969189, - 5.606014708057046, - 6.517311957897618, - 6.363795999903232, - 7.182386708911508, - 6.784844542155042, - 6.271677041891962, - 5.631998833967373, - 6.188035083934665, - 6.399571500020102, - 6.484463874949142, - 6.116879916982725, - 5.981871708063409, - 5.5048002088442445, - 5.660059459041804, - 5.530727708945051, - 5.8615260410588235, - 5.628177292179316, - 5.5764021668583155, - 5.693935291841626 - ], - "mean_time": 6.048622544043786, - "std_time": 0.45302403754498577, + 0.9763811668381095, + 0.9259937913157046, + 0.9161030002869666, + 0.9302584170363843, + 0.9357200828380883 + ], + "mean_time": 0.9302584170363842, + "std_time": 0.022343010023774743, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "MedianBlur(blur_limit=5, p=1.0)": { + "MedianBlur(blur_limit=5)": { "supported": true, "warmup_iterations": 11, "throughputs": [], - "median_throughput": 4.486480187602719, - "std_throughput": 0.21210241043331898, + "median_throughput": 6.465315898318219, + "std_throughput": 0.023474354432572935, "times": [], - "mean_time": 0.22117264168336986, + "mean_time": 0.15361908748745917, "std_time": 0.0, "variance_stable": false, "early_stopped": true, - "early_stop_reason": "Transform too slow: 0.221 sec/image > 0.1 sec/image threshold" + "early_stop_reason": "Transform too slow: 0.154 sec/image > 0.1 sec/image threshold" + }, + "MotionBlur(kernel_size=5, angle_range=(0, 360), direction_range=(-1, 1))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 160.537614244364, + 159.1824252718022, + 160.47934699269047, + 159.3406013105104, + 158.8920373500534 + ], + "median_throughput": 159.3406013105104, + "std_throughput": 0.7677743651039746, + "times": [ + 12.458139542024583, + 12.564201083034277, + 12.462662875186652, + 12.551728709135205, + 12.587163166608661 + ], + "mean_time": 12.551728709135205, + "std_time": 0.060479849212028446, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "CLAHE(clip_limit=(1, 4), tile_grid_size=(8, 8))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 160.05876344772156, + 164.7030907204295, + 159.6722599117252, + 166.48520992782892, + 166.76438479778213 + ], + "median_throughput": 164.7030907204295, + "std_throughput": 3.446087169162417, + "times": [ + 12.4954107911326, + 12.143062958028167, + 12.525657250080258, + 12.013079124968499, + 11.992968417238444 + ], + "mean_time": 12.143062958028167, + "std_time": 0.2540696308184202, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "MotionBlur(kernel_size=5, angle=45, direction=0.0, p=1.0)": { + "Brightness(brightness_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 81.63953883337517, - 82.58710066875497, - 81.04277468512622, - 70.49714324184723, - 74.06195786063755, - 75.7460670430658, - 55.671600687764034, - 70.67360318597117, - 76.06967126934575, - 76.07441344274494, - 77.23228926080081, - 76.12665015812304, - 67.30435977055866, - 66.32420440089415, - 76.66033370744424, - 75.11665052735101, - 66.73656951720362, - 67.7694482160036, - 78.85364127456455, - 74.24228991759489 - ], - "median_throughput": 75.4313587852084, - "std_throughput": 6.449254663783195, + 1128.6231363395634, + 1068.2678103592284, + 1127.3474449989983, + 1133.025663706024, + 1119.054637246726 + ], + "median_throughput": 1127.3474449989983, + "std_throughput": 26.75333453765415, "times": [ - 12.248966790968552, - 12.1084284579847, - 12.339162915945053, - 14.184971957933158, - 13.50220854114741, - 13.202005583094433, - 17.962479749927297, - 14.149554500123486, - 13.145843584090471, - 13.1450241249986, - 12.947952334070578, - 13.136004249798134, - 14.857878500130028, - 15.077451874967664, - 13.0445557909552, - 13.31262766616419, - 14.984288332983851, - 14.755911790998653, - 12.681722541106865, - 13.469412124948576 - ], - "mean_time": 13.257085860636696, - "std_time": 1.1334586064973702, + 1.7720707077533007, + 1.8721897080540657, + 1.7740759593434632, + 1.765185082796961, + 1.7872228338383138 + ], + "mean_time": 1.7740759593434632, + "std_time": 0.0421009936608918, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Posterize(bits=4, p=1.0)": { + "Contrast(contrast_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 23, "throughputs": [ - 316.92832647972847, - 422.8873469237624, - 321.859524111871, - 330.1453580938855, - 360.36192959093046, - 467.97728888030366, - 516.5509377494433, - 494.84136119472635, - 480.3828938917678, - 357.85004768445265, - 304.8435254336901, - 320.86708987965034, - 308.3416791639733, - 390.93815136580406, - 367.6184906717541, - 424.84283339012535, - 361.5881747644005, - 363.52513593192396, - 450.04377221404616, - 300.21645607038965 - ], - "median_throughput": 362.5566553481622, - "std_throughput": 69.00066918314737, + 1130.5680566134567, + 1115.0046714196817, + 1109.4622497718065, + 1107.4111275053583, + 1025.851895092168 + ], + "median_throughput": 1109.4622497718065, + "std_throughput": 41.15385563251513, "times": [ - 3.1552875412162393, - 2.3646959580946714, - 3.106945499777794, - 3.0289688329212368, - 2.774987915996462, - 2.1368558341637254, - 1.9359174999408424, - 2.0208496670238674, - 2.081672792090103, - 2.794466583058238, - 3.280371458036825, - 3.116555207874626, - 3.2431554589420557, - 2.5579493751283735, - 2.720211375039071, - 2.3538116249255836, - 2.765577167039737, - 2.7508414168842137, - 2.2220060841646045, - 3.3309299999382347 - ], - "mean_time": 2.7581896105029506, - "std_time": 0.524930175880918, + 1.769022208172828, + 1.7937144581228495, + 1.8026751251891255, + 1.8060139999724925, + 1.949599166866392 + ], + "mean_time": 1.8026751251891255, + "std_time": 0.0668675584677335, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "JpegCompression(quality=50, p=1.0)": { + "CoarseDropout(hole_height_range=(0.1, 0.1), hole_width_range=(0.1, 0.1), num_holes_range=(4, 4))": { + "supported": false + }, + "Blur(radius=5, border_mode=constant)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 72.56265862024938, - 72.1008795153458, - 73.61166671239323, - 74.4140186706742, - 74.75610330944087, - 72.63124761598417, - 68.12174312548557, - 67.2937641685049, - 68.46623587672624, - 67.92832972722658, - 68.95043255106317, - 68.22302333490141, - 68.77369987855884, - 65.67299036160122, - 68.98189984819342, - 68.20605109421132, - 68.70311792123401, - 67.01695292241504, - 64.84786928997879, - 68.9653289763083 - ], - "median_throughput": 68.73840889989643, - "std_throughput": 2.8350265028076684, + 241.72128277291674, + 266.09905226970204, + 264.72037335767277, + 265.7963460556983, + 265.2817925659599 + ], + "median_throughput": 265.2817925659599, + "std_throughput": 10.635643095808058, "times": [ - 13.78119295812212, - 13.869456332875416, - 13.584803125122562, - 13.438328125048429, - 13.376834207912907, - 13.76817874982953, - 14.679600875126198, - 14.86021791701205, - 14.605739415856078, - 14.721398332854733, - 14.503172249998897, - 14.65780833386816, - 14.540442084195092, - 15.22696004086174, - 14.496556374942884, - 14.661455749999732, - 14.555380166973919, - 14.921597542008385, - 15.420707124983892, - 14.500039582839236 - ], - "mean_time": 14.54790729090482, - "std_time": 0.600009563651192, + 8.273992165923119, + 7.515998207964003, + 7.555141958408058, + 7.5245579169131815, + 7.539152916055173 + ], + "mean_time": 7.539152916055173, + "std_time": 0.30225873733850933, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianNoise(mean=127, var=0.01, per_channel=True, p=1.0)": { + "HSV(hue=0.015, saturation=0.7, value=0.4)": { + "supported": false + }, + "ChannelDropout()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 66.21296805151412, - 63.96581496510221, - 65.89027334042555, - 60.983862720805206, - 62.08836352886776, - 60.994971009865694, - 64.1995589365746, - 64.944776603649, - 64.58746310628081, - 61.77727855633207, - 64.79410637468867, - 65.13447335100965, - 66.58600401318775, - 63.51691910657001, - 64.66821163077475, - 64.80675369846716, - 66.26629308855497, - 61.24323303441513, - 65.2655274696606, - 66.32029181050905 - ], - "median_throughput": 64.73115900273172, - "std_throughput": 1.8528246492734373, + 2273.357721366702, + 2282.646299477472, + 2272.4923848848484, + 2315.4127628487768, + 2322.535767731443 + ], + "median_throughput": 2282.646299477472, + "std_throughput": 23.91577119780579, "times": [ - 15.102781666908413, - 15.633350416086614, - 15.176746874814853, - 16.39778058300726, - 16.106077583041042, - 16.394794250139967, - 15.576430999906734, - 15.397697125095874, - 15.482880916912109, - 16.187181167071685, - 15.433502458035946, - 15.352853083051741, - 15.018171082949266, - 15.743836666923016, - 15.463548083091155, - 15.430490541970357, - 15.090628332924098, - 16.3283345841337, - 15.322024333057925, - 15.078341374872252 - ], - "mean_time": 15.44851066173246, - "std_time": 0.4421886119390117, + 0.8797559579834342, + 0.8761760420165956, + 0.8800909579731524, + 0.8637768747285008, + 0.8611277500167489 + ], + "mean_time": 0.8761760420165956, + "std_time": 0.009179882908124977, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True, p=1.0)": { + "LinearIllumination(gain=(0.01, 0.2))": { "supported": true, - "warmup_iterations": 6, - "throughputs": [], - "median_throughput": 0.8851101201585867, - "std_throughput": 0.09937228493468055, - "times": [], - "mean_time": 1.243876808299683, - "std_time": 0.0, - "variance_stable": false, - "early_stopped": true, - "early_stop_reason": "Transform timeout: 67.6 sec > 60 sec limit" + "warmup_iterations": 16, + "throughputs": [ + 700.8586597965933, + 711.2326105479975, + 707.011585706658, + 707.9659174950601, + 716.3778786787182 + ], + "median_throughput": 707.9659174950601, + "std_throughput": 5.706128375078557, + "times": [ + 2.8536424171179533, + 2.812019542325288, + 2.8288079579360783, + 2.82499474985525, + 2.791822667233646 + ], + "mean_time": 2.82499474985525, + "std_time": 0.022769150750409493, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)": { + "CornerIllumination(gain=(0.01, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 496.55546722869354, - 641.9671067976543, - 650.8251309074825, - 623.4720388168803, - 565.3237878425962, - 662.7131044508908, - 611.135281952472, - 621.2348157850546, - 635.7907935132064, - 665.2612835785991, - 637.316353961522, - 647.5719638599545, - 649.8685924454994, - 651.8744758375163, - 667.5579121214897, - 631.9519652828825, - 651.1625759888558, - 628.0584976863887, - 672.0164024296229, - 657.2885464366939 - ], - "median_throughput": 644.7695353288044, - "std_throughput": 40.23854176062675, + 453.07489186606017, + 452.35147279040467, + 448.48823455487576, + 447.77300657601774, + 452.9455957222388 + ], + "median_throughput": 452.35147279040467, + "std_throughput": 2.579367250735797, "times": [ - 2.0138737079687417, - 1.5577122089453042, - 1.5365110419224948, - 1.6039211668539792, - 1.7688977918587625, - 1.5089485831558704, - 1.6362989170011133, - 1.6096972909290344, - 1.5728444170672446, - 1.5031687919981778, - 1.5690794591791928, - 1.5442299169953912, - 1.538772625150159, - 1.5340376668609679, - 1.4979973749723285, - 1.582398750120774, - 1.5357147920876741, - 1.5922083749901503, - 1.4880589169915766, - 1.5214018339756876 - ], - "mean_time": 1.5509417632302425, - "std_time": 0.09679060732330509, + 4.414281249977648, + 4.421340750064701, + 4.4594257907010615, + 4.466548833064735, + 4.415541334077716 + ], + "mean_time": 4.421340750064701, + "std_time": 0.02521106312467928, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Clahe(clip_limit=(1, 4), tile_grid_size=(8, 8), p=1.0)": { + "GaussianIllumination(gain=(0.01, 0.2))": { "supported": true, - "warmup_iterations": 25, + "warmup_iterations": 16, "throughputs": [ - 91.02588436029748, - 91.73606127092317, - 88.89900428397651, - 90.51012876983913, - 91.23536134230247, - 89.83067468111234, - 91.00753693178338, - 91.31625035272053, - 90.63598545274071, - 87.1785215255696, - 87.28021909474455, - 89.34139278271657, - 92.16757880161144, - 84.26757487462517, - 88.62099811190022, - 89.56616634459603, - 90.03586106095823, - 90.20203643405759, - 91.2301661474408, - 87.74048263871373 - ], - "median_throughput": 90.11894874750791, - "std_throughput": 1.9254859998330414, + 409.49690896102993, + 429.1091368150827, + 444.48073955422365, + 435.6672934649094, + 436.4112409095093 + ], + "median_throughput": 435.6672934649094, + "std_throughput": 13.216923971659376, "times": [ - 10.985886124894023, - 10.900838624918833, - 11.248719915980473, - 11.048487209016457, - 10.960662459023297, - 11.132054874906316, - 10.988100916845724, - 10.950953375082463, - 11.033145334105939, - 11.470715292030945, - 11.457349790958688, - 11.193020042032003, - 10.849802208133042, - 11.86696070805192, - 11.284007417038083, - 11.164930250030011, - 11.106685583014041, - 11.086224208818749, - 10.961286625126377, - 11.397247540997341 - ], - "mean_time": 11.096445463448145, - "std_time": 0.23708721289728876, + 4.8840417503379285, + 4.6608189581893384, + 4.499632542021573, + 4.590659041889012, + 4.582833374850452 + ], + "mean_time": 4.590659041889012, + "std_time": 0.13926772205897697, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Brightness(brightness_limit=(0.2, 0.2), p=1.0)": { + "Hue(hue=20)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 479.2330067418688, - 529.8639958179434, - 529.5042875804415, - 518.0699227325057, - 529.8919909278736, - 519.4437873981459, - 517.6506467572088, - 534.6613011341312, - 519.2761135363303, - 531.9554860495615, - 502.4127533239107, - 489.0406797901851, - 517.0769063742533, - 506.007991018683, - 538.455698243726, - 516.7920709957541, - 509.30564021908936, - 526.971464522076, - 527.5568670246097, - 512.362276968853 - ], - "median_throughput": 518.673018134418, - "std_throughput": 15.07517165214673, + 148.80517028330456, + 150.74496465677052, + 149.73366452054177, + 149.72595564012403, + 149.94375516120786 + ], + "median_throughput": 149.73366452054177, + "std_throughput": 0.6915129460203965, "times": [ - 2.0866676250007004, - 1.8872767500579357, - 1.8885588340926915, - 1.930241374997422, - 1.8871770419646055, - 1.9251361249480397, - 1.9318047920241952, - 1.870342958951369, - 1.9257577499374747, - 1.8798565410543233, - 1.990395334083587, - 2.044819667004049, - 1.933948292164132, - 1.9762533749453723, - 1.8571630001533777, - 1.935014208080247, - 1.9634575410746038, - 1.8976359581574798, - 1.8955302499234676, - 1.9517440001945943 - ], - "mean_time": 1.9279969557638381, - "std_time": 0.05603700990172544, + 13.440393208060414, + 13.267441499978304, + 13.357049708254635, + 13.357737417332828, + 13.338334749918431 + ], + "mean_time": 13.357049708254637, + "std_time": 0.061686680970990906, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Contrast(contrast_limit=(0.2, 0.2), p=1.0)": { + "PlasmaBrightness(roughness=0.5)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 477.4741141810744, - 541.7430269893845, - 550.9931285712553, - 548.8495667611328, - 544.0863539899138, - 474.8487363747287, - 499.02820494220254, - 502.56440800965703, - 539.3163893820614, - 524.3385158427994, - 526.5916378582679, - 439.5067810756889, - 430.6567299876105, - 270.4362444457606, - 242.71583727805202, - 278.8516082146546, - 249.0818169296971, - 358.9701863976941, - 261.4208392581883, - 344.4674840461732 - ], - "median_throughput": 476.16142527790157, - "std_throughput": 116.01370523262199, + 84.2196260239644, + 84.91691707623457, + 86.42964567994477, + 87.32417613347337, + 85.09096507059654 + ], + "median_throughput": 85.09096507059654, + "std_throughput": 1.2542105817406997, "times": [ - 2.094354375032708, - 1.8458936251699924, - 1.8149046660400927, - 1.8219928748439997, - 1.8379435408860445, - 2.1059337919577956, - 2.0038947500288486, - 1.9897947090212256, - 1.8541991671081632, - 1.9071648749522865, - 1.8990047089755535, - 2.2752777501009405, - 2.3220349999610335, - 3.6977292080409825, - 4.120044292183593, - 3.586136749945581, - 4.014745083870366, - 2.785746666137129, - 3.825249749934301, - 2.9030316250864416 - ], - "mean_time": 2.100128122340803, - "std_time": 0.5116828705596812, + 23.74743387522176, + 23.552432999946177, + 23.140208249911666, + 22.903164834249765, + 23.504258041270077 + ], + "mean_time": 23.504258041270077, + "std_time": 0.34644440954297656, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "CoarseDropout(hole_height_range=(16, 16), hole_width_range=(16, 16), num_holes_range=(1, 1), p=1.0)": { + "PlasmaContrast(roughness=0.5)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 471.12566041204576, - 394.1223419016081, - 452.51906040099294, - 412.91072743971984, - 575.533854411002, - 620.5708369467844, - 478.870182439389, - 620.0337555876204, - 623.3296067599854, - 514.6511864379969, - 537.0137751171288, - 482.1185735682654, - 506.03202829588076, - 498.19640444977927, - 602.6873227734793, - 546.1060871232511, - 538.8409101916436, - 611.2469437875508, - 560.4221735621464, - 294.70838933478655 - ], - "median_throughput": 525.8324807775629, - "std_throughput": 86.04446030200741, + 84.63812331141787, + 84.3605958242927, + 84.12256510528512, + 84.43920442290639, + 84.74265757619034 + ], + "median_throughput": 84.43920442290639, + "std_throughput": 0.2427947662269866, "times": [ - 2.122575958026573, - 2.5372832079883665, - 2.209851667052135, - 2.4218310001306236, - 1.7375172500032932, - 1.6114195841364563, - 2.088248624932021, - 1.6128154168836772, - 1.604287666035816, - 1.9430636251345277, - 1.8621496250852942, - 2.074178542010486, - 1.9761594999581575, - 2.007240500068292, - 1.6592351659201086, - 1.8311460420954973, - 1.8558353330008686, - 1.6359999999403954, - 1.784369083121419, - 3.393184707965702 - ], - "mean_time": 1.9017463480408678, - "std_time": 0.3111917656865146, + 23.630013541784137, + 23.70775099983439, + 23.774833749979734, + 23.685680291149765, + 23.60086474986747 + ], + "mean_time": 23.685680291149765, + "std_time": 0.06810532203044779, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Blur(radius=5, p=1.0)": { - "supported": false + "PlasmaShadow(roughness=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 213.4922958894896, + 210.4111765864658, + 215.94059237471848, + 222.11339179595527, + 222.09789676223238 + ], + "median_throughput": 215.94059237471848, + "std_throughput": 5.215260833338648, + "times": [ + 9.368019542191178, + 9.505198499653488, + 9.261806583032012, + 9.004409791901708, + 9.00503799971193 + ], + "mean_time": 9.261806583032012, + "std_time": 0.2236853043110389, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "HSV(hue=0.015, saturation=0.7, value=0.4, p=1.0)": { - "supported": false + "Rain(drop_width=5, drop_height=20)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1493.984936918357, + 1488.247172173443, + 1493.4863927241302, + 1472.8426236658363, + 1494.9729200092206 + ], + "median_throughput": 1493.4863927241302, + "std_throughput": 9.244604431875498, + "times": [ + 1.3387015829794109, + 1.3438627920113504, + 1.3391484580934048, + 1.3579183327965438, + 1.3378168749623 + ], + "mean_time": 1.3391484580934048, + "std_time": 0.008289260505446256, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "SaltAndPepper(amount=(0.01, 0.06), salt_vs_pepper=(0.4, 0.6))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 487.52171417817425, + 480.4027649063624, + 473.242872548205, + 458.45818679178217, + 484.4535770104638 + ], + "median_throughput": 480.4027649063624, + "std_throughput": 11.571369047860498, + "times": [ + 4.102381374686956, + 4.163173374719918, + 4.226159792393446, + 4.362447999883443, + 4.1283625406213105 + ], + "mean_time": 4.163173374719918, + "std_time": 0.10027755676739443, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Saturation(saturation_factor=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 154.99202578251348, + 158.303893029792, + 155.12258700692817, + 154.2079276146753, + 152.51130355756285 + ], + "median_throughput": 154.99202578251348, + "std_throughput": 2.1064184452020434, + "times": [ + 12.903889667242765, + 12.633928084280342, + 12.893028917256743, + 12.969501833897084, + 13.113782082684338 + ], + "mean_time": 12.903889667242765, + "std_time": 0.1753702558096304, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Snow(snow_point_range=(0.5, 0.5))": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 142.26622906643635, + 142.94255401558289, + 143.12076321830992, + 143.83064818001367, + 140.4940377380074 + ], + "median_throughput": 142.94255401558289, + "std_throughput": 1.2674385132394965, + "times": [ + 14.058150083292276, + 13.991634707897902, + 13.974212790839374, + 13.90524220885709, + 14.235479542054236 + ], + "mean_time": 13.991634707897902, + "std_time": 0.12406058373656197, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "OpticalDistortion(distort_limit=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 173.502225411185, + 173.75696690645094, + 174.1096454379515, + 174.55428953594077, + 174.64818896450126 + ], + "median_throughput": 174.1096454379515, + "std_throughput": 0.49522018294074843, + "times": [ + 11.5272296667099, + 11.51032983371988, + 11.48701437516138, + 11.457753374706954, + 11.451593124773353 + ], + "mean_time": 11.48701437516138, + "std_time": 0.03267252280022422, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "Shear(shear=10)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 260.8422703434185, + 261.2299731292205, + 261.1844784799706, + 259.77275099645027, + 260.1784774363579 + ], + "median_throughput": 260.8422703434185, + "std_throughput": 0.6423685992798618, + "times": [ + 7.6674689166247845, + 7.656089291907847, + 7.657422874588519, + 7.699036917183548, + 7.687030917033553 + ], + "mean_time": 7.6674689166247845, + "std_time": 0.01888245053805719, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "ThinPlateSpline(num_control_points=4, distortion_scale=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 58.1177869627831, + 57.76735644580254, + 57.68996646380944, + 58.20403152199959, + 58.58105710411862 + ], + "median_throughput": 58.1177869627831, + "std_throughput": 0.35966137338615356, + "times": [ + 34.412872625049204, + 34.62162929121405, + 34.668073541950434, + 34.361880916170776, + 34.140729083213955 + ], + "mean_time": 34.412872625049204, + "std_time": 0.21296373584241626, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null } } } diff --git a/output/torchvision_results.json b/output/torchvision_results.json index 8f1c574..a5715f6 100644 --- a/output/torchvision_results.json +++ b/output/torchvision_results.json @@ -1,16 +1,16 @@ { "metadata": { "system_info": { - "python_version": "3.12.7 | packaged by Anaconda, Inc. | (main, Oct 4 2024, 08:22:19) [Clang 14.0.6 ]", - "platform": "macOS-15.0.1-arm64-arm-64bit", + "python_version": "3.12.8 | packaged by Anaconda, Inc. | (main, Dec 11 2024, 10:37:40) [Clang 14.0.6 ]", + "platform": "macOS-15.1-arm64-arm-64bit", "processor": "arm", - "cpu_count": "10", - "timestamp": "2024-11-02T16:52:32.623562+00:00" + "cpu_count": "16", + "timestamp": "2025-01-24T00:05:11.345897+00:00" }, "library_versions": { "torchvision": "0.20.1", - "numpy": "2.1.2", - "pillow": "11.0.0", + "numpy": "2.2.2", + "pillow": "11.1.0", "opencv-python-headless": "not installed", "torch": "2.5.1", "opencv-python": "not installed" @@ -22,8 +22,8 @@ "pillow": "{'threads': 'unknown', 'simd': False}" }, "benchmark_params": { - "num_images": 1000, - "num_runs": 20, + "num_images": 2000, + "num_runs": 5, "max_warmup_iterations": 1000, "warmup_window": 5, "warmup_threshold": 0.05, @@ -31,982 +31,692 @@ } }, "results": { - "HorizontalFlip(p=1.0)": { + "Resize(target_size=512, interpolation=bilinear)": { "supported": true, - "warmup_iterations": 18, + "warmup_iterations": 16, "throughputs": [ - 740.576236805059, - 842.7414885970853, - 865.6059171521704, - 860.5955043756717, - 864.9025772229157, - 826.4404468545376, - 850.2162668728312, - 864.2481807865875, - 861.7330939783725, - 861.2765236017855, - 870.4988591610094, - 889.2600391097886, - 851.4973383153286, - 881.1615912188056, - 896.7829367208769, - 764.0412879151374, - 847.760899246678, - 861.6637911339378, - 879.5099580895816, - 858.1289080551969 - ], - "median_throughput": 861.4701573678617, - "std_throughput": 37.7963910543144, + 268.73661644504085, + 260.1697072894327, + 249.85758249322987, + 261.5253086483284, + 245.5909793468516 + ], + "median_throughput": 260.1697072894327, + "std_throughput": 9.344765379241814, "times": [ - 1.3502998750191182, - 1.1866035000421107, - 1.1552601249422878, - 1.1619860839564353, - 1.1561995840165764, - 1.2100085418205708, - 1.1761713330633938, - 1.1570750419050455, - 1.160452124895528, - 1.1610672909300774, - 1.148766583064571, - 1.124530459055677, - 1.1744017919991165, - 1.1348656250629574, - 1.1150970419403166, - 1.3088297920767218, - 1.1795778749510646, - 1.1605454590171576, - 1.1369967909995466, - 1.165326084010303 - ], - "mean_time": 1.160806316327199, - "std_time": 0.05092955234140045, + 7.4422310828231275, + 7.687290041707456, + 8.004559957887977, + 7.647443416994065, + 8.14362158300355 + ], + "mean_time": 7.687290041707456, + "std_time": 0.27611178330620334, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "VerticalFlip(p=1.0)": { + "RandomCrop128(height=128, width=128)": { "supported": true, - "warmup_iterations": 16, + "warmup_iterations": 38, "throughputs": [ - 3238.857219612126, - 3332.6501408011954, - 3275.340697680685, - 3354.685434219066, - 3302.012370447355, - 2725.740424053197, - 3252.4115239983357, - 3189.9457183934005, - 2918.9328448960296, - 3315.388791363397, - 2975.855762982257, - 1857.2489069556154, - 3094.4591392345847, - 3084.432874280384, - 3131.7499768354464, - 3165.987588977626, - 2130.3481965418123, - 2640.4194328677686, - 3258.8642130583494, - 3145.014657542121 - ], - "median_throughput": 3155.5011232598736, - "std_throughput": 402.29761940212, + 31538.942993539622, + 31586.303727296057, + 31449.58982283231, + 30988.81431651121, + 31221.075641195275 + ], + "median_throughput": 31449.58982283231, + "std_throughput": 249.14475783388775, "times": [ - 0.30875087482854724, - 0.30006149993278086, - 0.30531174992211163, - 0.29809054220095277, - 0.3028456249739975, - 0.3668727921321988, - 0.3074641670100391, - 0.3134849581401795, - 0.3425909581128508, - 0.30162375001236796, - 0.33603779203258455, - 0.5384307920467108, - 0.323158249957487, - 0.3242087089456618, - 0.3193102921359241, - 0.3158572078682482, - 0.4694068329408765, - 0.3787277080118656, - 0.3068553749471903, - 0.3179635419510305 - ], - "mean_time": 0.3169068749900883, - "std_time": 0.04040273680808262, + 0.06341366609558463, + 0.06331858318299055, + 0.0635938341729343, + 0.064539416693151, + 0.06405929196625948 + ], + "mean_time": 0.0635938341729343, + "std_time": 0.0005037925932897663, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Rotate(angle=45, p=1.0, interpolation=nearest, mode=reflect)": { + "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear)": { + "supported": true, + "warmup_iterations": 17, + "throughputs": [ + 755.2792843061796, + 837.3193074204585, + 836.064055022779, + 844.6286728665476, + 836.951462954496 + ], + "median_throughput": 836.951462954496, + "std_throughput": 37.48240926663955, + "times": [ + 2.6480270829051733, + 2.388575042132288, + 2.392161208204925, + 2.367904458194971, + 2.3896248331293464 + ], + "mean_time": 2.3896248331293464, + "std_time": 0.10701802906574183, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "HorizontalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 171.0968134956512, - 177.1314801210756, - 146.130061349045, - 135.94722307333797, - 155.44209476534843, - 169.06039633698182, - 171.99762557340054, - 165.6772204672737, - 149.2807374114002, - 142.5652515238185, - 159.66332115232905, - 157.0276323168701, - 160.71674416930443, - 158.54821207717282, - 162.835465927297, - 162.55966117274448, - 162.33010800413538, - 149.04307636906907, - 159.68941471424816, - 175.60931363790255 - ], - "median_throughput": 160.2030794417763, - "std_throughput": 10.94944797333919, + 2655.9953210195476, + 2485.9186977380955, + 2573.0080283488, + 2465.934401860682, + 2374.7442400330624 + ], + "median_throughput": 2485.9186977380955, + "std_throughput": 107.3477742139858, "times": [ - 5.844644207973033, - 5.645523874787614, - 6.843218915862963, - 7.355795708019286, - 6.43326379195787, - 5.915045875124633, - 5.814033749978989, - 6.035832790890709, - 6.698787916917354, - 7.014331958955154, - 6.263179249828681, - 6.368305916897953, - 6.222127042012289, - 6.307229749858379, - 6.141168290982023, - 6.1515876250341535, - 6.160286667058244, - 6.709469667170197, - 6.262155834119767, - 5.694458791986108 - ], - "mean_time": 6.2420772652091046, - "std_time": 0.426629129097424, + 0.7530133747495711, + 0.8045315407216549, + 0.7773003340698779, + 0.8110515829175711, + 0.8421959578990936 + ], + "mean_time": 0.8045315407216549, + "std_time": 0.034741550582487034, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Affine(angle=25.0, shift=(50, 50), scale=2.0, shear=[10.0, 15.0], p=1.0, interpolation=bilinear, mode=reflect)": { + "VerticalFlip()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 139.5771958998461, - 141.36849723714093, - 141.2315018520024, - 140.37586902306896, - 137.63158611925903, - 126.5323742755722, - 113.67282290439931, - 105.64906287168273, - 128.8072276854029, - 129.83119666444952, - 128.76730132980646, - 134.62407304459148, - 133.88283011239923, - 116.7659418884608, - 116.28578606838396, - 113.03208192248142, - 74.33832640076504, - 122.51362490893713, - 123.62785889223723, - 135.3929771932397 - ], - "median_throughput": 128.78726450760468, - "std_throughput": 15.956213522182654, + 4912.384042334619, + 4767.422768248097, + 4599.632638733682, + 4490.860391171013, + 4696.317978956326 + ], + "median_throughput": 4696.317978956326, + "std_throughput": 160.66772979394685, "times": [ - 7.164494124939665, - 7.073711750097573, - 7.080573291983455, - 7.123731500003487, - 7.265773999970406, - 7.903115749824792, - 8.797177499858662, - 9.465299292001873, - 7.7635394998360425, - 7.702309041982517, - 7.765946709085256, - 7.428092000074685, - 7.469217667123303, - 8.564141082810238, - 8.599503291072324, - 8.84704575012438, - 13.452011208981276, - 8.162357458146289, - 8.088791708927602, - 7.3859074579086155 - ], - "mean_time": 7.764742917891168, - "std_time": 0.962019780577071, + 0.40713429218158126, + 0.4195138751529157, + 0.4348173337057233, + 0.44534895895048976, + 0.425865541677922 + ], + "mean_time": 0.425865541677922, + "std_time": 0.014569466992110904, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Equalize(p=1.0)": { + "Pad(padding=10, fill=0, border_mode=constant)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 442.4232990576504, - 457.6773284698, - 386.3556008419462, - 416.78787516438, - 411.0181428075939, - 411.7845461642146, - 370.44807871815306, - 454.7303782868059, - 475.90545235317467, - 470.5679177935556, - 415.6057536750405, - 420.77582028925355, - 442.8504862061268, - 376.9864238821554, - 385.0743513086952, - 464.67122128669365, - 462.83365713244734, - 338.76559009627846, - 364.5016962183766, - 332.3677542677632 - ], - "median_throughput": 416.1968144197102, - "std_throughput": 44.056659238903435, + 5033.180715467926, + 4889.1855950850795, + 4948.230681842232, + 4858.148143868722, + 4550.653749670613 + ], + "median_throughput": 4889.1855950850795, + "std_throughput": 183.19502120188304, "times": [ - 2.2602787921205163, - 2.184945457847789, - 2.588289124891162, - 2.3993020420894027, - 2.432982624974102, - 2.4284544170368463, - 2.699433624977246, - 2.199105333071202, - 2.1012577079236507, - 2.125091750174761, - 2.4061264579650015, - 2.3765624158550054, - 2.258098457939923, - 2.652615417027846, - 2.596901083132252, - 2.1520592500455678, - 2.1606034578289837, - 2.951893666991964, - 2.7434714580886066, - 3.0087154579814523 - ], - "mean_time": 2.4027094041896206, - "std_time": 0.25433964365652706, + 0.3973630419932306, + 0.40906608290970325, + 0.4041848750784993, + 0.41167950024828315, + 0.43949729204177856 + ], + "mean_time": 0.40906608290970325, + "std_time": 0.015327474949396002, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomCrop80(height=80, width=80, p=1.0)": { + "Rotate(angle=45, interpolation=nearest, mode=constant, fill=0)": { "supported": true, - "warmup_iterations": 34, + "warmup_iterations": 24, "throughputs": [ - 27335.007682659467, - 28785.020769673218, - 27961.143050856972, - 28406.736907041806, - 28590.795972888824, - 27781.37861396605, - 29236.524425910095, - 28749.469969865575, - 28808.86223425408, - 29682.728854182584, - 28680.962800875273, - 28861.555674290907, - 26414.49625800602, - 28919.286297014012, - 29446.804727227885, - 27917.364699265487, - 30221.599656437957, - 29038.042484879465, - 28249.285856562095, - 29314.48117320955 - ], - "median_throughput": 28767.245369769396, - "std_throughput": 857.6858967017987, + 261.26766188956384, + 262.4047556929937, + 254.89858119985962, + 252.22680672178197, + 258.3533802150072 + ], + "median_throughput": 258.3533802150072, + "std_throughput": 4.272260133134954, "times": [ - 0.036583124892786145, - 0.03474029107019305, - 0.03576391702517867, - 0.035202916944399476, - 0.03497629100456834, - 0.035995333921164274, - 0.0342037919908762, - 0.0347832499537617, - 0.03471154090948403, - 0.033689624862745404, - 0.0348663330078125, - 0.034648166969418526, - 0.03785800002515316, - 0.03457899997010827, - 0.03395954193547368, - 0.03581999987363815, - 0.033088916912674904, - 0.03443758306093514, - 0.0353991249576211, - 0.034112832974642515 - ], - "mean_time": 0.034761757239741446, - "std_time": 0.001036410283496563, + 7.654984874650836, + 7.621813083067536, + 7.84625787474215, + 7.9293712908402085, + 7.741334749851376 + ], + "mean_time": 7.741334749851376, + "std_time": 0.12801456594652733, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomResizedCrop(height=512, width=512, scale=(0.08, 1.0), ratio=(0.75, 1.3333333333333333), interpolation=bilinear, p=1.0)": { + "Affine(angle=25.0, shift=(20, 20), scale=2.0, shear=(10.0, 15.0), interpolation=bilinear, mode=constant, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 474.4091358551224, - 401.1030198131269, - 376.05982471648406, - 440.89116382477596, - 483.34882419215626, - 494.3739216747146, - 486.65388230968966, - 451.20969897885016, - 507.4333809743065, - 465.49396983725154, - 463.8635060947598, - 485.27980552236255, - 530.6351010768208, - 406.7945469484409, - 431.81891496764564, - 459.66346776757257, - 393.1041666991987, - 352.0049365161348, - 409.19801431454016, - 474.04537369457177 - ], - "median_throughput": 461.7634869311662, - "std_throughput": 46.90773500023627, + 187.7311050578477, + 187.6569765401613, + 186.3393171599938, + 190.48305846120888, + 187.79510093810765 + ], + "median_throughput": 187.7311050578477, + "std_throughput": 1.512894068311513, "times": [ - 2.107885207980871, - 2.4931250840891153, - 2.659151375060901, - 2.2681334579829127, - 2.068899208912626, - 2.022760417079553, - 2.0548484998289496, - 2.216264415998012, - 1.9707020418718457, - 2.1482555409893394, - 2.1558065828867257, - 2.0606668330729008, - 1.8845342081040144, - 2.458243374945596, - 2.3157855418976396, - 2.1755046248435974, - 2.5438550000544637, - 2.8408692500088364, - 2.443804625188932, - 2.109502709005028 - ], - "mean_time": 2.1656108122491444, - "std_time": 0.21999118806414444, + 10.653535541612655, + 10.65774391591549, + 10.7331079156138, + 10.499621415976435, + 10.649905082769692 + ], + "mean_time": 10.653535541612655, + "std_time": 0.08585508897145815, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ShiftRGB(pixel_shift=100, p=1.0, per_channel=True)": { - "supported": false - }, - "Resize(target_size=512, interpolation=bilinear, p=1.0)": { + "Perspective(scale=(0.05, 0.1), interpolation=bilinear, fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 173.99483996220025, - 156.4621672023894, - 173.99092965041245, - 192.32829051271517, - 180.8174204227238, - 168.96681781406377, - 160.2639386791262, - 178.73775972970375, - 173.02538563937998, - 184.6800638335957, - 177.03670214037174, - 186.12647962619187, - 172.94186709924386, - 177.86835096251238, - 191.22521355526618, - 195.83947522408306, - 182.97796967630518, - 196.23313650048016, - 191.48575044299838, - 193.36455353595844 - ], - "median_throughput": 179.77759007621378, - "std_throughput": 11.283959010147868, + 153.7607368001166, + 150.84376486643023, + 143.2207389652988, + 146.7236005619246, + 141.77389158979886 + ], + "median_throughput": 146.7236005619246, + "std_throughput": 5.044888149366217, "times": [ - 5.747296875109896, - 6.391321415780112, - 5.747426041169092, - 5.199443084187806, - 5.530440582893789, - 5.918321792036295, - 6.239706875057891, - 5.594788708956912, - 5.7794987498782575, - 5.414769625058398, - 5.648546250071377, - 5.372690667165443, - 5.782289833994582, - 5.622135667130351, - 5.229435916990042, - 5.106222833041102, - 5.465138791128993, - 5.095979291945696, - 5.222320708911866, - 5.171578666893765 - ], - "mean_time": 5.56242855172364, - "std_time": 0.3491325907078685, + 13.007221749983728, + 13.258751541841775, + 13.9644580418244, + 13.631072249729186, + 14.106969750020653 + ], + "mean_time": 13.631072249729186, + "std_time": 0.46868557336684435, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "RandomGamma(gamma=120, p=1.0)": { - "supported": false + "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True)": { + "supported": true, + "warmup_iterations": 11, + "throughputs": [], + "median_throughput": 3.172784237184834, + "std_throughput": 0.1126560907051603, + "times": [], + "mean_time": 0.30012217089533805, + "std_time": 0.0, + "variance_stable": false, + "early_stopped": true, + "early_stop_reason": "Transform too slow: 0.300 sec/image > 0.1 sec/image threshold" + }, + "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 86.44467701457258, + 87.66466755606078, + 88.04164264031746, + 87.49313137912166, + 87.32129871109245 + ], + "median_throughput": 87.49313137912166, + "std_throughput": 0.5935116581904234, + "times": [ + 23.136184541042894, + 22.814208457712084, + 22.71652300003916, + 22.858937249984592, + 22.903919542208314 + ], + "mean_time": 22.858937249984592, + "std_time": 0.15506412375299525, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "Grayscale(p=1.0, num_output_channels=3)": { + "ChannelShuffle()": { "supported": true, - "warmup_iterations": 43, + "warmup_iterations": 16, "throughputs": [ - 1066.676670009329, - 1204.9884110205817, - 1513.6813130728185, - 1645.904156132091, - 1058.1422723896978, - 1058.0162322312972, - 812.3606080127813, - 965.2734824372677, - 1203.9086698667497, - 1480.9339026495772, - 1614.5832385729595, - 989.8692652352288, - 1350.6126210247628, - 1564.9144109218003, - 1659.6408540603297, - 1766.603812206798, - 1805.8709758995512, - 1759.0621380878715, - 1667.0811193856864, - 1664.3408663506484 - ], - "median_throughput": 1497.307607861198, - "std_throughput": 317.4845967774298, + 4559.365793779506, + 4186.832148274046, + 4314.807258719196, + 4417.262726301525, + 4793.26976320739 + ], + "median_throughput": 4417.262726301525, + "std_throughput": 233.6173994628964, "times": [ - 0.937491208082065, - 0.8298835000023246, - 0.6606410420499742, - 0.6075687920674682, - 0.9450525001157075, - 0.9451650830451399, - 1.2309804169926792, - 1.0359758329577744, - 0.8306277918163687, - 0.6752495828550309, - 0.6193548750597984, - 1.0102344169281423, - 0.7404047499876469, - 0.639012583065778, - 0.6025399998761714, - 0.5660578750539571, - 0.5537494169548154, - 0.568484750110656, - 0.599850834114477, - 0.6008384581655264 - ], - "mean_time": 0.6678654371017535, - "std_time": 0.14161217634011256, + 0.4386574998497963, + 0.4776881253346801, + 0.4635201250202954, + 0.4527690843679011, + 0.4172517089173198 + ], + "mean_time": 0.45276908436790114, + "std_time": 0.023945765194679426, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "ColorJitter(brightness=0.5, contrast=1.5, saturation=1.5, hue=0.5, p=1.0)": { + "Grayscale(num_output_channels=1)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 45.02743963647953, - 46.27878418591268, - 46.66670607271724, - 45.564187299756526, - 46.98668367592637, - 47.499145638333474, - 43.87197937937806, - 49.398775732899004, - 48.671428488528996, - 45.07075000865419, - 42.44659604628005, - 43.163889971159286, - 43.53695459979305, - 46.40989238679391, - 45.67064389046156, - 48.7756212468615, - 49.2883679729386, - 48.82677469421654, - 48.67876867090862, - 49.366751695328716 - ], - "median_throughput": 46.53829922975558, - "std_throughput": 2.2327611251616415, + 2600.2035878652373, + 2612.548448718872, + 2618.0290663797523, + 2559.607935115105, + 2585.9588904823436 + ], + "median_throughput": 2600.2035878652373, + "std_throughput": 23.448559728044817, "times": [ - 22.20868004206568, - 21.608173541957512, - 21.42855333397165, - 21.947061042068526, - 21.282625666819513, - 21.0530102502089, - 22.79359204089269, - 20.243416666984558, - 20.54593487503007, - 22.187338790856302, - 23.559015166014433, - 23.167513416148722, - 22.96899287495762, - 21.54713033302687, - 21.895903250202537, - 20.502045375062153, - 20.288762666052207, - 20.48056637495756, - 20.542836791137233, - 20.256548499921337 - ], - "mean_time": 21.487678246750832, - "std_time": 1.0309111732353844, + 0.7691705408506095, + 0.7655360423959792, + 0.7639334588311613, + 0.7813696670345962, + 0.7734074997715652 + ], + "mean_time": 0.7691705408506095, + "std_time": 0.006936357388459544, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "PlankianJitter(mode=blackbody, p=1.0)": { + "RGBShift(pixel_shift=100)": { "supported": false }, - "RandomPerspective(scale=(0.05, 0.1), p=1.0, interpolation=bilinear)": { + "GaussianBlur(sigma=2.0, kernel_size=(5, 5))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 103.86700450635344, - 108.40335832008856, - 108.7767445528949, - 107.3229388010385, - 108.79904132544291, - 105.05757773274019, - 109.1600694440395, - 99.70592485298525, - 95.57706803760142, - 99.83451057034833, - 97.85702971990094, - 100.99068751057007, - 106.67271382121257, - 106.01066887030669, - 106.85874550633703, - 106.92024490091676, - 108.26224183384619, - 108.94801733623224, - 106.05094384592391, - 105.32847171453457 - ], - "median_throughput": 106.36182883356824, - "std_throughput": 4.060472658802428, + 124.38468193004252, + 127.17084406014074, + 129.93251329441767, + 129.38125076628285, + 119.99002493061397 + ], + "median_throughput": 127.17084406014074, + "std_throughput": 4.08808517899011, "times": [ - 9.627696540905163, - 9.224806458922103, - 9.193141457857564, - 9.31767254206352, - 9.191257457947358, - 9.518589915940538, - 9.160858957795426, - 10.029494249960408, - 10.462760791182518, - 10.0165763751138, - 10.218989916844293, - 9.901903082849458, - 9.374468541936949, - 9.433012834051624, - 9.358148416038603, - 9.352765707997605, - 9.23683070903644, - 9.178689291002229, - 9.429430457996204, - 9.494109082967043 - ], - "mean_time": 9.40186917587483, - "std_time": 0.3589260653839806, + 16.079150334000587, + 15.72687525022775, + 15.392606125213206, + 15.458190334029496, + 16.668052208144218 + ], + "mean_time": 15.72687525022775, + "std_time": 0.5055624667543885, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianBlur(sigma=2.0, kernel_size=(5, 5), p=1.0)": { + "GaussianNoise(mean=0, std=0.44, per_channel=True)": { + "supported": false + }, + "Invert()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 82.4255903216825, - 82.4810664943329, - 81.64415461541059, - 80.61061167961732, - 82.71688802721557, - 81.08437978704491, - 84.2094315941303, - 84.00979949080391, - 82.58668801563819, - 79.89257298772446, - 81.15388132022656, - 82.44935033509486, - 82.25640336903783, - 82.34600388959628, - 78.73890561247556, - 83.46641415935721, - 83.27610183120282, - 74.69657736752349, - 73.76912072603429, - 74.659519460862 - ], - "median_throughput": 82.30120362931706, - "std_throughput": 3.1190876996841506, + 4243.802950916812, + 4225.237928279612, + 4220.185362387556, + 4296.311216519017, + 4254.944576735482 + ], + "median_throughput": 4243.802950916812, + "std_throughput": 30.37900389902373, "times": [ - 12.132154542021453, - 12.12399454205297, - 12.248274291167036, - 12.405314625008032, - 12.089429666055366, - 12.332831583917141, - 11.875154374865815, - 11.903373250039294, - 12.108488959027454, - 12.516808041138574, - 12.322269541909918, - 12.12865833309479, - 12.157108249841258, - 12.143880124902353, - 12.700201916974038, - 11.980866916012019, - 12.008247000165284, - 13.387494249967858, - 13.555807499913499, - 13.394139250041917 - ], - "mean_time": 12.150490587039037, - "std_time": 0.46048470816848974, + 0.4712754157371819, + 0.47334612486884, + 0.47391283279284835, + 0.4655156247317791, + 0.47004137514159083 + ], + "mean_time": 0.47127541573718196, + "std_time": 0.0033735962432235285, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "MedianBlur(blur_limit=5, p=1.0)": { - "supported": false + "Posterize(bits=4)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 4264.947418681492, + 4207.749572009094, + 4275.8789939609815, + 4238.086508731166, + 4247.14339533553 + ], + "median_throughput": 4247.14339533553, + "std_throughput": 26.343348000338242, + "times": [ + 0.46893895836547017, + 0.4753134581260383, + 0.4677400840446353, + 0.47191108437255025, + 0.4709047502838075 + ], + "mean_time": 0.4709047502838075, + "std_time": 0.0029208356198575426, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "MotionBlur(kernel_size=5, angle=45, direction=0.0, p=1.0)": { - "supported": false + "Solarize(threshold=0.5)": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 1042.6397063947732, + 1045.0616424193536, + 1032.1547160685984, + 1029.1857349587094, + 1008.6010773224657 + ], + "median_throughput": 1032.1547160685984, + "std_throughput": 14.47542966977909, + "times": [ + 1.9182081669569016, + 1.9137627091258764, + 1.9376939996145666, + 1.9432838330976665, + 1.9829445406794548 + ], + "mean_time": 1.9376939996145668, + "std_time": 0.027175144168124343, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "Posterize(bits=4, p=1.0)": { + "Sharpen(alpha=(0.2, 0.5), lightness=(0.5, 1))": { "supported": true, - "warmup_iterations": 26, + "warmup_iterations": 16, "throughputs": [ - 2693.5002137178562, - 3115.8148409819746, - 3131.4124673322567, - 3047.975906321366, - 3156.360164537436, - 1474.5554402766, - 2685.386496966321, - 2984.992580120688, - 2973.553589708808, - 3051.2456705131694, - 3187.6819490943576, - 3107.548764372008, - 3175.827713517366, - 2977.948660991694, - 3052.0077449361524, - 3109.4035904642806, - 3176.2421349267493, - 3036.2240446994397, - 3242.774793590188, - 2998.1010720870145 - ], - "median_throughput": 3051.626707724661, - "std_throughput": 380.14970353526587, + 216.13016135598033, + 219.42484797478502, + 222.6179699901719, + 222.55017052839503, + 220.4086316241496 + ], + "median_throughput": 220.4086316241496, + "std_throughput": 2.672750527064949, "times": [ - 0.37126412498764694, - 0.3209433329757303, - 0.3193447079975158, - 0.3280865829437971, - 0.31682062498293817, - 0.6781704998575151, - 0.3723858748562634, - 0.3350092079490423, - 0.33629795792512596, - 0.32773500005714595, - 0.3137075831182301, - 0.32179704192094505, - 0.31487854197621346, - 0.33580162515863776, - 0.3276531659066677, - 0.3216050830669701, - 0.31483745807781816, - 0.32935645896941423, - 0.3083778750151396, - 0.3335444589611143 - ], - "mean_time": 0.327694077872852, - "std_time": 0.040821770971623976, + 9.253683000337332, + 9.114738000091165, + 8.98400070797652, + 8.986737665720284, + 9.074054792057723 + ], + "mean_time": 9.074054792057723, + "std_time": 0.11003509503858833, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "JpegCompression(quality=50, p=1.0)": { + "AutoContrast()": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 625.5691048663607, - 521.6015864099544, - 580.1749717295266, - 560.9877346730968, - 522.7912136557957, - 496.4400182241779, - 599.496602568609, - 546.0734947515396, - 551.6768078949613, - 557.7096315054724, - 632.6489564286444, - 618.5974357955314, - 634.5064601296474, - 629.5236685541037, - 623.1343291929877, - 606.8389999350735, - 606.1636079477146, - 606.5423322863477, - 617.3269158047102, - 618.7987182986049 - ], - "median_throughput": 606.3529701170312, - "std_throughput": 42.464409216348216, + 341.2565399588579, + 342.8451579802102, + 343.9269620917758, + 345.0110294708772, + 343.9899657233198 + ], + "median_throughput": 343.9269620917758, + "std_throughput": 1.4250666024188743, "times": [ - 1.598544416949153, - 1.9171720831654966, - 1.7236179579049349, - 1.7825701672118157, - 1.9128095000050962, - 2.014342041919008, - 1.6680661670397967, - 1.8312553339637816, - 1.8126554999034852, - 1.7930477501358837, - 1.5806554169394076, - 1.616560208844021, - 1.576028082985431, - 1.588502625003457, - 1.6047904170118272, - 1.6478835409507155, - 1.649719625012949, - 1.648689541965723, - 1.6198872500099242, - 1.616034375037998 - ], - "mean_time": 1.6492044226434508, - "std_time": 0.11549789468504777, + 5.860693542286754, + 5.833537249825895, + 5.815188166219741, + 5.796916124876589, + 5.814123082906008 + ], + "mean_time": 5.81518816621974, + "std_time": 0.024095320681051583, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "GaussianNoise(mean=127, var=0.01, per_channel=True, p=1.0)": { - "supported": false + "Equalize()": { + "supported": true, + "warmup_iterations": 16, + "throughputs": [ + 791.6451224811805, + 794.664161381646, + 792.4667451243379, + 799.3963224203335, + 796.6052005994766 + ], + "median_throughput": 794.664161381646, + "std_throughput": 3.1495949809098964, + "times": [ + 2.5263845417648554, + 2.5167864579707384, + 2.5237652081996202, + 2.5018879170529544, + 2.5106539581902325 + ], + "mean_time": 2.5167864579707384, + "std_time": 0.009975104429353617, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "Elastic(alpha=50.0, sigma=5.0, interpolation=bilinear, approximate=False, same_dxdy=True, p=1.0)": { + "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))": { "supported": true, - "warmup_iterations": 11, - "throughputs": [], - "median_throughput": 2.5179910199953315, - "std_throughput": 0.20205401736282502, - "times": [], - "mean_time": 0.46989290418568996, - "std_time": 0.0, - "variance_stable": false, - "early_stopped": true, - "early_stop_reason": "Transform too slow: 0.470 sec/image > 0.1 sec/image threshold" + "warmup_iterations": 16, + "throughputs": [ + 1026.8049354695293, + 1010.7673252804539, + 1017.8857800211667, + 1009.9340904539935, + 1017.5690719785213 + ], + "median_throughput": 1017.5690719785213, + "std_throughput": 6.804174860351097, + "times": [ + 1.947789624799043, + 1.978694749996066, + 1.964856999926269, + 1.980327249970287, + 1.9654685417190194 + ], + "mean_time": 1.9654685417190194, + "std_time": 0.01314249028262306, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null }, - "Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)": { + "Erasing(scale=(0.02, 0.33), ratio=(0.3, 3.3), fill=0)": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 480.27491890874484, - 544.0098531369014, - 538.5265844517252, - 516.3112846694526, - 507.4430261139117, - 532.7314295060406, - 539.3047432746873, - 532.0677335191737, - 536.6384060318086, - 511.603704863746, - 515.7920038166872, - 478.08139234475937, - 518.7826893727541, - 562.3443274615851, - 528.2691572804803, - 535.708856967954, - 526.8084246842421, - 533.3359169422904, - 525.5688018674806, - 518.9928123793733 - ], - "median_throughput": 527.5387909823612, - "std_throughput": 19.863309659936547, + 3610.415152081074, + 3577.1394823439477, + 3479.8267922024675, + 3577.28664714661, + 3548.374963955114 + ], + "median_throughput": 3577.1394823439477, + "std_throughput": 49.21250458656708, "times": [ - 2.0821407919283956, - 1.8382019998971373, - 1.8569185419473797, - 1.9368160830345005, - 1.9706645840778947, - 1.8771184589713812, - 1.854239207925275, - 1.87945995782502, - 1.8634521658532321, - 1.9546379169914871, - 1.9387659998610616, - 2.0916940420866013, - 1.9275893750600517, - 1.7782699160743505, - 1.8929744169581681, - 1.8666855830233544, - 1.8982232499402016, - 1.8749909170437604, - 1.9027004579547793, - 1.9268089579418302 - ], - "mean_time": 1.8955952000000622, - "std_time": 0.07137445642125215, + 0.5539529155939817, + 0.559105958789587, + 0.5747412499040365, + 0.5590829579159617, + 0.5636382908560336 + ], + "mean_time": 0.559105958789587, + "std_time": 0.007691901503175414, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Clahe(clip_limit=(1, 4), tile_grid_size=(8, 8), p=1.0)": { + "JpegCompression(quality=50)": { + "supported": true, + "warmup_iterations": 17, + "throughputs": [ + 892.0013790118184, + 892.3077823909521, + 888.7909736596862, + 881.1726558391205, + 875.5952130581404 + ], + "median_throughput": 888.7909736596862, + "std_throughput": 7.334056876420792, + "times": [ + 2.242149000056088, + 2.2413790840655565, + 2.250247875228524, + 2.2697027497924864, + 2.2841605003923178 + ], + "mean_time": 2.250247875228524, + "std_time": 0.01856842203855473, + "variance_stable": true, + "early_stopped": false, + "early_stop_reason": null + }, + "RandomGamma(gamma=120)": { + "supported": false + }, + "PlankianJitter(mode=blackbody)": { + "supported": false + }, + "MedianBlur(blur_limit=5)": { "supported": false }, - "Brightness(brightness_limit=(0.2, 0.2), p=1.0)": { + "MotionBlur(kernel_size=5, angle_range=(0, 360), direction_range=(-1, 1))": { + "supported": false + }, + "CLAHE(clip_limit=(1, 4), tile_grid_size=(8, 8))": { + "supported": false + }, + "Brightness(brightness_limit=(0.2, 0.2))": { "supported": true, - "warmup_iterations": 17, + "warmup_iterations": 16, "throughputs": [ - 419.04826497644615, - 428.62407280473485, - 441.2410182047314, - 448.1216811721902, - 432.1706614917835, - 437.66155765725796, - 446.2466860689512, - 447.19125893655945, - 450.802953400887, - 442.7275388089713, - 450.4587019601217, - 450.9975474398613, - 449.65169420367556, - 455.8342569275217, - 451.00379350317274, - 457.39732691754847, - 453.70225572069876, - 457.0165465544545, - 453.86626265804324, - 401.5687887096356 - ], - "median_throughput": 448.88668768793286, - "std_throughput": 14.101675659084481, + 856.0870725245223, + 825.9392839832443, + 848.079027621902, + 854.3951528461477, + 857.1719855313169 + ], + "median_throughput": 854.3951528461477, + "std_throughput": 13.005249043739529, "times": [ - 2.3863599579781294, - 2.3330467499326915, - 2.266335083870217, - 2.2315367499832064, - 2.313900708919391, - 2.2848705409560353, - 2.2409129999578, - 2.236179665895179, - 2.2182640829123557, - 2.258725541876629, - 2.2199593340046704, - 2.2173069580458105, - 2.223943583201617, - 2.1937798329163343, - 2.217276250012219, - 2.1862829998135567, - 2.2040886669419706, - 2.188104582950473, - 2.203292208025232, - 2.4902333749923855 - ], - "mean_time": 2.227733696338089, - "std_time": 0.06998375960396659, + 2.3362109581939876, + 2.421485499944538, + 2.358270791824907, + 2.3408372499980032, + 2.333254042081535 + ], + "mean_time": 2.3408372499980032, + "std_time": 0.03563125481889099, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "Contrast(contrast_limit=(0.2, 0.2), p=1.0)": { + "Contrast(contrast_limit=(0.2, 0.2))": { "supported": true, "warmup_iterations": 16, "throughputs": [ - 344.15708808690744, - 359.04679356881064, - 359.3640800912368, - 361.29190758488494, - 358.09464815753535, - 350.072175500547, - 358.28329630005567, - 356.79780385652526, - 355.0119035393361, - 355.33365893401475, - 356.47678142390413, - 358.4978242600958, - 355.4823577863792, - 357.607619325319, - 358.43233347460034, - 355.334132295845, - 356.3526821027158, - 360.04946356117455, - 360.85998890082845, - 358.6305869477121 - ], - "median_throughput": 357.85113374142713, - "std_throughput": 3.885729592320152, + 614.422115190534, + 611.409746570309, + 596.1138592475392, + 601.5947827644763, + 581.1799474769623 + ], + "median_throughput": 601.5947827644763, + "std_throughput": 13.281217850323712, "times": [ - 2.905649875057861, - 2.785152291879058, - 2.782693250104785, - 2.767845000140369, - 2.792557792039588, - 2.8565537908580154, - 2.791087416931987, - 2.802707833936438, - 2.8168069578241557, - 2.814256333047524, - 2.8052317909896374, - 2.7894172079395503, - 2.813079125015065, - 2.7963610000442713, - 2.7899268749170005, - 2.8142525840085, - 2.8062087090220302, - 2.777396166929975, - 2.7711578749585897, - 2.78838458401151 - ], - "mean_time": 2.7944581020178383, - "std_time": 0.030343647169651176, + 3.2550911670550704, + 3.2711287499405444, + 3.3550637499429286, + 3.3244969160296023, + 3.44127495912835 + ], + "mean_time": 3.324496916029602, + "std_time": 0.07339386751597624, "variance_stable": true, "early_stopped": false, "early_stop_reason": null }, - "CoarseDropout(hole_height_range=(16, 16), hole_width_range=(16, 16), num_holes_range=(1, 1), p=1.0)": { + "CoarseDropout(hole_height_range=(0.1, 0.1), hole_width_range=(0.1, 0.1), num_holes_range=(4, 4))": { + "supported": false + }, + "Blur(radius=5, border_mode=constant)": { + "supported": false + }, + "HSV(hue=0.015, saturation=0.7, value=0.4)": { + "supported": false + }, + "ChannelDropout()": { + "supported": false + }, + "LinearIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "CornerIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "GaussianIllumination(gain=(0.01, 0.2))": { + "supported": false + }, + "Hue(hue=20)": { + "supported": false + }, + "PlasmaBrightness(roughness=0.5)": { + "supported": false + }, + "PlasmaContrast(roughness=0.5)": { + "supported": false + }, + "PlasmaShadow(roughness=0.5)": { + "supported": false + }, + "Rain(drop_width=5, drop_height=20)": { + "supported": false + }, + "SaltAndPepper(amount=(0.01, 0.06), salt_vs_pepper=(0.4, 0.6))": { + "supported": false + }, + "Saturation(saturation_factor=0.5)": { + "supported": false + }, + "Snow(snow_point_range=(0.5, 0.5))": { + "supported": false + }, + "OpticalDistortion(distort_limit=0.5)": { "supported": false }, - "Blur(radius=5, p=1.0)": { + "Shear(shear=10)": { "supported": false }, - "HSV(hue=0.015, saturation=0.7, value=0.4, p=1.0)": { + "ThinPlateSpline(num_control_points=4, distortion_scale=0.5)": { "supported": false } } diff --git a/pyproject.toml b/pyproject.toml index f1985bc..0d96502 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -102,46 +102,13 @@ format.skip-magic-trailing-comma = false # Like Black, automatically detect the appropriate line ending. lint.select = [ "ALL" ] lint.ignore = [ - "ANN101", - "ANN102", - "ANN204", - "ANN401", - "ARG001", - "ARG002", "ARG004", - "B008", - "B027", - "BLE001", - "C901", "D100", - "D101", "D102", - "D103", - "D104", "D105", - "D106", - "D107", - "D205", "D415", - "EM101", - "EM102", - "F403", - "FBT001", - "FBT002", - "FBT003", - "G004", "N802", "N812", - "PD901", - "PLR0913", - "PLR2004", - "PTH123", - "S311", - "T201", - "TCH001", - "TCH002", - "TCH003", - "TRY003", ] # Allow fix for all enabled rules (when `--fix`) is provided. diff --git a/requirements-dev.txt b/requirements-dev.txt index c363173..107ec53 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -1,2 +1,4 @@ +pandas pre_commit>=3.5.0 pytest>=8.3.3 +tabulate diff --git a/requirements/albumentations.txt b/requirements/albumentations.txt index 49f00f6..ac4b394 100644 --- a/requirements/albumentations.txt +++ b/requirements/albumentations.txt @@ -1 +1,2 @@ -git+https://github.com/albumentations-team/albumentations.git +# git+https://github.com/albumentations-team/albumentations.git +../albumentations diff --git a/run_all.sh b/run_all.sh index 3eb19ed..aa7d859 100755 --- a/run_all.sh +++ b/run_all.sh @@ -71,6 +71,7 @@ mkdir -p "$OUTPUT_DIR" # Libraries to benchmark LIBRARIES=("albumentations" "imgaug" "torchvision" "kornia" "augly") + # Run benchmarks for each library for library in "${LIBRARIES[@]}"; do echo "Running benchmark for ${library}..." @@ -88,8 +89,8 @@ done # Generate comparison table echo "Generating comparison table..." -python -m benchmark.compare_results -r "$OUTPUT_DIR" -o"${OUTPUT_DIR}/comparison.md" +python -m tools.compare_results -r "$OUTPUT_DIR" -o"${OUTPUT_DIR}/comparison.md" echo "All benchmarks complete." echo "Individual results saved in: $OUTPUT_DIR" -echo "Comparison table saved as: ${OUTPUT_DIR}/comparison.csv" +echo "Comparison table saved as: ${OUTPUT_DIR}/comparison.md" diff --git a/run_single.sh b/run_single.sh index c24b1d0..180b871 100755 --- a/run_single.sh +++ b/run_single.sh @@ -93,7 +93,7 @@ echo "Installing requirements..." pip install -U uv uv pip install setuptools uv pip install -U -r "${SCRIPT_DIR}/requirements/requirements.txt" -uv pip install -U -r "${SCRIPT_DIR}/requirements/${LIBRARY}.txt" +uv pip install -U --force-reinstall -r "${SCRIPT_DIR}/requirements/${LIBRARY}.txt" # Run benchmark echo "Running benchmark..." diff --git a/speedup_analysis.png b/speedup_analysis.png new file mode 100644 index 0000000..f426721 Binary files /dev/null and b/speedup_analysis.png differ diff --git a/tools/__init__.py b/tools/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/benchmark/compare_results.py b/tools/compare_results.py similarity index 98% rename from benchmark/compare_results.py rename to tools/compare_results.py index 14f44c5..9380797 100644 --- a/benchmark/compare_results.py +++ b/tools/compare_results.py @@ -135,6 +135,8 @@ def main() -> None: df = create_comparison_table(args.results_dir) markdown_table = df.to_markdown(index=False) + df.to_csv(args.output.with_suffix(".csv"), index=False) + # Combine summary and table full_report = f"""# Benchmark Results diff --git a/tools/generate_tables.py b/tools/generate_tables.py new file mode 100644 index 0000000..b82e4b7 --- /dev/null +++ b/tools/generate_tables.py @@ -0,0 +1,158 @@ +import csv +from pathlib import Path +from typing import Any, Tuple + +def parse_throughput(value: str) -> Tuple[float, float]: + """Parse throughput string like '3662 ± 54' or '-' into (value, std)""" + if value == '-': + return (0, 0) + # Remove bold markers if present + value = value.replace('**', '') + parts = value.split('±') + return (float(parts[0].strip()), float(parts[1].strip())) + +def load_results_from_csv(csv_path: Path) -> dict[str, list[Tuple[float, float]]]: + """Load results from CSV file into a dictionary mapping transform names to lists of (value, std) tuples""" + import pandas as pd + + df = pd.read_csv(csv_path) + results = {} + + # Select only the columns we want, using partial matches + albumentations_col = [col for col in df.columns if col.startswith('albumentations')][0] + torchvision_col = [col for col in df.columns if col.startswith('torchvision')][0] + kornia_col = [col for col in df.columns if col.startswith('kornia')][0] + + columns = ['Transform', albumentations_col, torchvision_col, kornia_col] + df = df[columns] + + for _, row in df.iterrows(): + transform = row['Transform'] + # Get throughput values for each library (skip the Transform column) + throughputs = [parse_throughput(val) for val in row.iloc[1:]] + results[transform] = throughputs + + return results + +def format_throughput(value: float, std: float) -> str: + if value == 0: + return "-" + return f"{int(value)} ± {int(std)}" + + +def calculate_speedup(values: list[float]) -> float: + """Calculate speedup ratio between Albumentations and the best of other libraries. + Returns > 1 if Albumentations is faster, < 1 if another library is faster.""" + albumentations_value = values[0] # First value is Albumentations + other_values = [v for v in values[1:] if v > 0] # Rest are other libraries + + if albumentations_value == 0 or not other_values: + return 0 + + best_other = max(other_values) + return albumentations_value / best_other + + +# Sets of transform names to look for in results +SPATIAL_TRANSFORMS: set[str] = { + "Resize", + "RandomCrop128", + "HorizontalFlip", + "VerticalFlip", + "Rotate", + "Affine", + "Perspective", + "Elastic", + "Shear", + "RandomResizedCrop", + "Pad", + "Erasing", + "OpticalDistortion", + "ThinPlateSpline", +} + +PIXEL_TRANSFORMS: set[str] = { + "ChannelShuffle", + "Grayscale", + "GaussianBlur", + "GaussianNoise", + "Invert", + "Posterize", + "Solarize", + "Sharpen", + "Equalize", + "JpegCompression", + "RandomGamma", + "MedianBlur", + "MotionBlur", + "CLAHE", + "Brightness", + "Contrast", + "Blur", + "Saturation", + "ColorJitter", + "AutoContrast", + "Normalize", + "RGBShift", + "PlankianJitter", + "ChannelDropout", + "LinearIllumination", + "CornerIllumination", + "GaussianIllumination", + "Hue", + "PlasmaBrightness", + "PlasmaContrast", + "PlasmaShadow", + "Rain", + "SaltAndPepper", + "Snow", +} + +def generate_comparison_tables(csv_path: Path) -> str: + results = load_results_from_csv(csv_path) + + markdown = "## Performance Comparison (images/second, higher is better)\n\n" + + # Generate tables for both categories + for category, transforms in [("Spatial Transformations", SPATIAL_TRANSFORMS), + ("Pixel-Level Transformations", PIXEL_TRANSFORMS)]: + markdown += f"### {category}\n" + markdown += "| Transform | Albumentations | TorchVision | Kornia | Speedup* |\n" + markdown += "|-----------|---------------|-------------|--------|----------|\n" + + for transform_name in sorted(transforms): + if transform_name not in results: + continue + + throughputs = results[transform_name] + values = [t[0] for t in throughputs] + + # Format strings and bold the highest value + max_val = max(values) + formatted = [] + for val, std in throughputs: + if val == 0: + formatted.append("-") + elif val == max_val: + formatted.append(f"**{format_throughput(val, std)}**") + else: + formatted.append(format_throughput(val, std)) + + # Calculate speedup + speedup = calculate_speedup(values) + speedup_str = f"{speedup:.1f}x" if speedup > 0 else "-" + + markdown += f"| {transform_name} | {' | '.join(formatted)} | {speedup_str} |\n" + + markdown += "\n*Speedup shows how many times the fastest library is faster than the second-best library\n\n" + + return markdown + +if __name__ == "__main__": + import argparse + parser = argparse.ArgumentParser(description='Generate comparison tables from benchmark results') + parser.add_argument("-f", '--file', type=str, help='Path to CSV file containing benchmark results') + args = parser.parse_args() + + markdown = generate_comparison_tables(Path(args.file)) + print(markdown)