cornucopia 0.3.0__tar.gz → 0.4.0__tar.gz

cornucopia-0.4.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: cornucopia
+Version: 0.4.0
+Summary: An abundance of augmentation layers
+Author: Yael Balbastre
+Author-email: yael.balbastre@gmail.com
+License: MIT
+Project-URL: Source Code, https://github.com/balbasty/cornucopia
+Platform: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=1.8
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: torch-interpol>=0.2.4
+Requires-Dist: torch-distmap
+Dynamic: license-file
+
+<picture align="center">
+  <source media="(prefers-color-scheme: dark)" srcset="docs/icons/cornucopia_lightorange.svg">
+  <source media="(prefers-color-scheme: light)"  srcset="docs/icons/cornucopia_orange.svg">
+  <img alt="Cornucopia logo" src="https://github.com/balbasty/cornucopia/raw/main/docs/icons/cornucopia_orange.svg">
+</picture>
+
+The `cornucopia` package provides a generic framework for preprocessing,
+augmentation, and domain randomization; along with an abundance of specific layers,
+mostly targeted at (medical) imaging. `cornucopia` is written using a PyTorch
+backend, and therefore runs **on the CPU or GPU**.
+
+Cornucopia is *intended* to be used on the GPU for on-line augmentation.
+A quick [benchmark](docs/examples/benchmark.ipynb) of affine and elastic augmentation
+shows that while cornucopia is slower than [TorchIO](https://github.com/fepegar/torchio)
+on the CPU (~ 3s vs 1s), it is greatly accelerated on the GPU (~ 50ms).
+
+Since gradients are not expected to backpropagate through its layers, it can
+theoretically be used within any dataloader pipeline,
+independent of the downstream learning framework (pytorch, tensorflow, jax, ...).
+
+## Installation
+
+### Dependencies
+
+- `pytorch >= 1.8`
+- `numpy`
+- `nibabel`
+- `torch-interpol`
+- `torch-distmap`
+
+### Conda
+
+```sh
+conda install cornucopia -c balbasty -c pytorch -c conda-forge
+```
+
+### Pip (release)
+
+```sh
+pip install cornucopia
+```
+
+### Pip (dev)
+
+```sh
+pip install cornucopia@git+https://github.com/balbasty/cornucopia
+```
+
+## Documentation
+
+Read the [documentation](https://cornucopia.readthedocs.io) and in particular:
+- [installation](https://cornucopia.readthedocs.io/en/latest/install/)
+- [get started](https://cornucopia.readthedocs.io/en/latest/start/)
+- [examples](https://cornucopia.readthedocs.io/en/latest/examples/overview/)
+- [API](https://cornucopia.readthedocs.io/en/latest/api/overview/)
+
+## Other augmentation packages
+
+There are other great, and much more mature, augmentation packages 
+out-there (although few run on the GPU). Here's a non-exhaustive list:
+- [MONAI](https://github.com/Project-MONAI/MONAI)
+- [TorchIO](https://github.com/fepegar/torchio)
+- [Albumentations](https://github.com/albumentations-team/albumentations) (2D only)
+- [Volumentations](https://github.com/ZFTurbo/volumentations) (3D extension of Albumentations)
+
+## Contributions
+
+If you find this project useful and wish to contribute, please reach out!

{cornucopia-0.3.0 → cornucopia-0.4.0}/README.md

@@ -10,7 +10,7 @@ mostly targeted at (medical) imaging. `cornucopia` is written using a PyTorch
 backend, and therefore runs **on the CPU or GPU**.
 
 Cornucopia is *intended* to be used on the GPU for on-line augmentation.
-A quick [benchmark](examples/benchmark.ipynb) of affine and elastic augmentation
+A quick [benchmark](docs/examples/benchmark.ipynb) of affine and elastic augmentation
 shows that while cornucopia is slower than [TorchIO](https://github.com/fepegar/torchio)
 on the CPU (~ 3s vs 1s), it is greatly accelerated on the GPU (~ 50ms).
 

{cornucopia-0.3.0 → cornucopia-0.4.0}/cornucopia/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-04-19T14:23:50+0100",
+ "date": "2025-04-16T18:13:05+0100",
  "dirty": false,
  "error": null,
- "full-revisionid": "37de94f181b9a97eebd21460f4df63ae4a0750f8",
- "version": "0.3.0"
+ "full-revisionid": "6f8ab58dfcfe8978c9aa9e8b05898dcf7d75bb5b",
+ "version": "0.4.0"
 }
 '''  # END VERSION_JSON
 

{cornucopia-0.3.0 → cornucopia-0.4.0}/cornucopia/base.py

@@ -447,6 +447,8 @@ class SequentialTransform(SpecialMixin, SharedMixin, Transform):
     def make_final(self, x, max_depth=float('inf')):
         if max_depth == 0:
             return self
+        if self.is_final:
+            return self
         # x = VirtualTensor.from_any(x, compute_stats=True)
         trf = []
         for t in self:
@@ -477,12 +479,23 @@ class SequentialTransform(SpecialMixin, SharedMixin, Transform):
             x = args[0]
         else:
             return None
-        for trf in self.transforms:
+        for trf in self:
             with IncludeKeysTransform(trf, self.include), \
                  ExcludeKeysTransform(trf, self.exclude):
                 x = trf(x)
         return x
 
+    def xform(self, x):
+        # This should only be called when a Layer's `make_final` returns
+        # a `SequentialTransform`` (i.e., it is created implictly under
+        # the hood, not explicitly by the user).
+        # In such cases, `shared=False` and hopefully we can just fallback
+        # to `forward()`.
+        #
+        # FIXME
+        #   what happens if there's weird stuff in returns/include/exclude?
+        return self(x)
+
     def __len__(self):
         return len(self.transforms)
 
@@ -556,9 +569,11 @@ class MaybeTransform(SpecialMixin, SharedMixin, Transform):
         img = (0.2 * gauss)(img)
         ```
         ```
-    """
 
-    def __init__(self, transform, prob=0.5, *, shared=False, **kwargs):
+    !!! changedin "![v0.4](https://img.shields.io/badge/v0.4-yellow) \
+                   Default for `shared` changed from `False` to `True`"
+    """
+    def __init__(self, transform, prob=0.5, *, shared=True, **kwargs):
         """
 
         Parameters
@@ -617,9 +632,12 @@ class SwitchTransform(SpecialMixin, SharedMixin, Transform):
         ```python
         img = cc.switch({gauss: 0.5, chi: 0.5})(img)
         ```
+
+    !!! changedin "![v0.4](https://img.shields.io/badge/v0.4-yellow) \
+                   Default for `shared` changed from `False` to `True`"
     """
 
-    def __init__(self, transforms, prob=0, *, shared=False, **kwargs):
+    def __init__(self, transforms, prob=0, *, shared=True, **kwargs):
         """
 
         Parameters

{cornucopia-0.3.0 → cornucopia-0.4.0}/cornucopia/baseutils.py

@@ -117,6 +117,29 @@ def returns_find(flag, returned, returns):
             return None
 
 
+def returns_update(value, flag, returned, returns):
+    """Find tensor corresponding to flag in returned structure"""
+    if returns is None:
+        if flag == 'output':
+            return value
+        else:
+            return None
+    if isinstance(returns, dict):
+        if flag in returns:
+            returned[flag] = value
+        return returned
+    elif isinstance(returns, (list, tuple)):
+        if flag in returns:
+            returned[returns.index(flag)] = value
+        return returned
+    else:
+        assert isinstance(returns, str)
+        if returns == flag:
+            return value
+        else:
+            return None
+
+
 def flatstruct(x):
     """Flatten a nested structure of tensors"""
 

{cornucopia-0.3.0 → cornucopia-0.4.0}/cornucopia/contrast.py

@@ -184,7 +184,7 @@ class ContrastLookupTransform(NonFinalTransform):
 
         vmin, vmax = x.min(), x.max()
         edges = torch.linspace(vmin, vmax, self.nk+1)
-        new_mu = torch.rand(self.nk) * (vmax - vmin) + vmin
+        new_mu = torch.rand(self.nk).to(x) * (vmax - vmin) + vmin
         return self.LookupFinalTransform(
             edges, new_mu, **self.get_prm()
         ).make_final(x, max_depth-1)