FastTransform

0.0.2 · active · verified Mon Apr 13

Fasttransform is a Python library designed for creating reusable, reversible, and extensible data transformations. It is a core building block for data pipelines, particularly within the fastai ecosystem, and leverages multiple dispatch for type-based specialization of transforms. The current version is 0.0.2, and it appears to have a low release cadence with infrequent updates.

Warnings

breaking Migration from `fastcore.dispatch`'s `typedispatch` to `plum-dispatch` may introduce `AmbiguousLookupError` where `fastcore` would silently pick a function. `plum` is stricter to prevent unexpected behavior.
Fix: Review type dispatch definitions to ensure unique matches for argument types, or explicitly specify the desired function.
breaking The `Pipeline` class has moved from `fastcore` to `fasttransform`. Older `fastai` versions (specifically 2.7.x) might expect `Pipeline` in `fastcore`, leading to `ModuleNotFoundError` when loading models or using certain functionalities.
Fix: Ensure `fasttransform` is installed and `Pipeline` is imported directly from `fasttransform`. If using `fastai` with older saved models, consider retraining or upgrading `fastai` and `fasttransform` to compatible versions. Downgrading `fastai` to v2.7.x was a workaround for some users, but generally updating is recommended.
gotcha When implementing custom reversible transforms, remember to define both `encodes` and `decodes` methods for the `Transform` class or pass both functions to the `Transform` constructor. Forgetting the `decodes` method will prevent reversibility.
Fix: Always implement or provide the inverse function(s) (`decodes`) for any transform intended to be reversible.
gotcha Fasttransform's type-based multiple dispatch, powered by `plum-dispatch`, will return the original input if no matching type annotation is found for an argument. This can lead to unexpected no-op behavior if types are not correctly annotated or handled.
Fix: Carefully annotate types in `encodes`/`decodes` methods or decorator arguments. Provide a default implementation without type hints if a fallback behavior is desired for unhandled types.
gotcha There is another unrelated library named `fastflowtransform` on PyPI. Ensure you are installing and importing the correct library (`fasttransform`) for data pipeline transformations described here to avoid confusion.
Fix: Double-check the package name during installation (`pip install fasttransform`) and imports (`from fasttransform import ...`).

Install

pip install fasttransform From PyPI
pip install git+https://github.com/AnswerDotAI/fasttransform.git From GitHub (latest develop branch)

Imports

Transform
```
from fasttransform import Transform
```
Pipeline
```
from fasttransform import Pipeline
```
The Pipeline class was moved from fastcore to fasttransform. Direct import from fastcore may lead to ModuleNotFoundError, especially with newer fastai versions.

Quickstart

This quickstart demonstrates how to define a simple transform using the `@Transform` decorator, create a reversible transform by passing encode and decode functions, and compose multiple transforms into a `Pipeline`.

from fasttransform import Transform, Pipeline

# Create a simple transform using a decorator
@Transform
def add_one(x: int) -> int:
    return x + 1

# Create a reversible transform
def multiply_by_two_encodes(x: int) -> int:
    return x * 2

def multiply_by_two_decodes(x: int) -> int:
    return x // 2

MultiplyByTwo = Transform(multiply_by_two_encodes, multiply_by_two_decodes)

# Use a Pipeline to chain transforms
my_pipeline = Pipeline([add_one, MultiplyByTwo])

# Demonstrate usage
result_encoded = my_pipeline(5)
print(f"Encoded result: {result_encoded}") # Expected: (5 + 1) * 2 = 12

result_decoded = MultiplyByTwo.decode(result_encoded)
print(f"Decoded result (MultiplyByTwo): {result_decoded}") # Expected: 12 // 2 = 6

view raw JSON →