fasttransform：可逆管道变得简单

而这只是为了一个简单的规范化。在实际项目中，您可能正在处理： - 需要与图像同步转换的分割掩码 - 带有分词、填充和特殊词元的文本数据 - 带有滑动窗口、规范化和编码的时间序列

每次转换都会增加另一层复杂性。最糟糕的是：因为查看转换后的数据非常痛苦，我们中的许多人只是......不要。我们最终根据抽象数字而不是实际数据来调试模型，希望我们的转换正在执行我们认为它们正在做的事情。

还记得在我们的 fastai 示例中准确查看模型所看到的内容是多么容易吗？这不是魔法 - 这是可逆转换的力量。让我们看看 fasttransform 如何实现这一点。

更好的方法：可逆管道

以下是 fastai 如何处理与上一节的 pytorch 示例相同的管道：

就是这样。无需手动反函数。不记得均值和标准差。只是，我们又回到了我们可以真正关注的东西。.decode()

FastTransform 将此功能引入您自己的代码中。关键的见解是，对于要应用的任何转换，您可能已经知道如何撤消它。让我们看看它的内部是如何工作的。

运作方式：.decode()

fasttransform 背后的核心思想很简单：将 transform 与其 reverse 配对。

以下是编写可逆规范化转换的方法：

class Normalize(Transform):
    def __init__(self, mean=None, std=None):
        self.mean = mean
        self.std = std
        
    def encodes(self, x): return (x-self.mean) / self.std  # forward transform
    def decodes(self, x): return x*self.std + self.mean    # inverse transform

就这样。

通过同时定义 和 ，fasttransform 会自动知道如何反转转换。将此与我们之前的 PyTorch 示例进行比较 - 我们不是编写单独的正向和反函数，而是将它们放在它们所属的位置。encodesdecodes

你可能会注意到这个奇特的名字 - 还有一个 's'。我们稍后会解释原因，但这与 fasttransform 如何自动处理不同类型的数据有关。encodesdecodes

当您调用 时，fasttransform 会智能地决定要反转哪些转换。某些转换（例如加载图像或调整图像大小）不需要撤消，您实际上希望看到模型所看到的内容！其他的，比如规范化，需要反转才能让人看到。decode()

你怎么做呢？好吧，只有在需要反转 transform 时才定义一个方法！.decodes

简介的绘图函数正是使用此功能将转换后的输入转换回人类可解释的状态。

问题 #2：处理多种类型

我们已经看到，使转换可逆如何使查看数据变得更加容易。但是，使用转换时还有另一个挑战：不同类型的数据需要不同的转换。

您最常看到这种情况，您的输入和标签需要不同的转换。同样的原则在这里也适用。我们希望将所有这些转换放在一个地方，因为我们希望能够撤消它们。例如，我们希望将分类标签从字符串转换为整数，然后再转换回字符串，以便于人类阅读。但我们不想为输入和输出维护单独的转换管道。

要了解为什么这是一个问题，让我们看看 PyTorch（最流行的深度学习框架之一）如何处理这种情况。以下是本教程中的一个示例，其中显示了一个典型的自定义数据集：

class CustomImageDataset(Dataset):
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        self.img_labels = pd.read_csv(annotations_file)  
        self.img_dir = img_dir
        self.transform = transform
        self.target_transform = target_transform  # <- separate target transform

    def __len__(self):
        return len(self.img_labels)

    def __getitem__(self, idx):
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        image = read_image(img_path)
        label = self.img_labels.iloc[idx, 1]
        if self.transform:
            image = self.transform(image)
        if self.target_transform:  # <- separate target transform
            label = self.target_transform(label)
        return image, label

图像和标签的转换是单独定义的，并提供给 dataset 类。这种分离乍一看似乎很合理，但它会产生两个问题：

1. 当我们想要反转转换时，我们必须记住反转两个管道
2. 当我们有需要同时应用于输入和目标的转换时，我们必须将它们保留在两个位置（例如，调整图像和蒙版大小以进行图像分割）

让我们看看 fasttransform 如何使这变得更容易。

更好的方法：输入和输出都使用一个管道

这就是 fasttransform 方法的亮点：它不是处理单独的管道，而是在单个转换中同时处理您的图像及其标签。将元组传递给转换时，它仅应用相关的转换。这听起来像是一件小事，但它改变了现实世界机器学习工作的游戏规则。

让我们看看它的实际效果。

首先，我们将创建一个同时加载图像及其标签的函数：

def load_img_and_label(fp): return PILImage.create(fp), parent_label(fp)
load_img_and_label(fpath)

(PILImage mode=RGB size=375x500, 'husky')

现在是很酷的部分 - 我们只需做一个小改动，就可以在转换管道中使用这个函数。看看这有多干净：

transforms_ft = Pipeline([
   load_img_and_label,  # <-- Load img and label as a tuple
   Resize(256,method="squish"),
   Resize(224,method="crop"),
   ToTensor(),
   IntToFloatTensor(),
   Normalize.from_stats(*imagenet_stats)
])

out = transforms_ft(fpath)
print((out[0][0,:2,:2,:2], out[1])) 

(TensorImage([[[-0.2856, -0.2856],
              [-0.2856, -0.2856]],

             [[ 0.5553,  0.5553],
              [ 0.5553,  0.5553]]], device='mps:0'), 'husky')

但我们还没有完成！这些字符串标签 （“husky”、“wolf”） 需要转换为我们模型的数字。在 PyTorch 中，我们需要一个单独的转换管道来实现此目的。使用 fasttransform，我们只添加另一个仅适用于字符串的 transform：

class StrCategorize(Transform):
    def __init__(self, vocab):
        self.vocab = vocab
        self.s2i = {s:i for i,s in enumerate(vocab)}
        self.i2s = {i:s for i,s in enumerate(vocab)}
    def encodes(self, s:str): return self.s2i[s]
    def decodes(self, i:int): return self.i2s[i]
    
transforms_ft = Pipeline([
   load_img_and_label,
   Resize(256,method="squish"),
   Resize(224,method="crop"),
   ToTensor(),
   IntToFloatTensor(),
   Normalize.from_stats(*imagenet_stats),
   StrCategorize(vocab=['husky','wolf']), # <-- Transform is just for the target label
])

out = transforms_ft(fpath)
print((out[0][0,:2,:2,:2], out[1])) 

(TensorImage([[[-0.2856, -0.2856],
              [-0.2856, -0.2856]],

             [[ 0.5553,  0.5553],
              [ 0.5553,  0.5553]]], device='mps:0'), 0)

你可能会想，“好吧，将转换保存在一个管道中很好，但它真的那么重要吗？

嗯，一个好处是现在您还可以一次性再次反转两个转换：

rev = transforms_ft.decode(out)
print((rev[0][0,:2,:2,:2], rev[1])) 

(TensorImage([[[107, 107],
              [107, 107]],

             [[148, 148],
              [148, 148]]], device='mps:0'), 'husky')

接下来，我们将展示另一个示例，说明为什么将这些转换保存在一个位置至关重要：图像分割。

在分割中，您尝试识别图像中的特定区域 - 就像在照片中寻找哈士奇一样。但这里有一个棘手的部分：您的输入图像和目标蒙版都需要以完全相同的方式转换。当你使用随机转换作为数据增强的一种形式时，这就会变得很棘手。举个例子，如果你对图像应用了随机裁剪，那么你最好以完全相同的方式裁剪该蒙版！

让我们看看这在实践中是什么样子的。首先，我们定义一个新函数，用于加载图像及其相应的掩码：

fnames = list(Path("./segment_huskies/img/").glob("*"))
fn = fnames[0]

def load_img_msk(fn): 
    return PILImage.create(fn), PILMask.create(fn.parent.parent / "msk" / fn.name)

img, msk = load_img_msk(fn)

show_images([img,msk])

transforms_ft = Pipeline([
   load_img_msk,  # <-- New load func for img and mask
   RandomResizedCrop(200),  # Applied to both img and mask
   ToTensor(),              # Applied to both img and mask
   IntToFloatTensor(),                   # Only applied to img
  Normalize.from_stats(*imagenet_stats)  # Only applied to img
])

out = transforms_ft(fn)
out
show_images((out[0][0], out[1]))

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for 

rev = transforms_ft.decode(out)
show_images((rev[0][0], rev[1]))

from functools import singledispatch

@singledispatch 
def greet(x): return "Hello stranger!"

@greet.register
def _(x:str): return f"Hello {x}!"

@greet.register
def _(x:int): return f"Hello number {x}!"

greet(None), greet("Alice"), greet(42)

('Hello stranger!', 'Hello Alice!', 'Hello number 42!')

from plum import dispatch

class Dog: pass
class Cat: pass

@dispatch
def greet(a: Cat, b: Dog):
    return "Hiss!"

@dispatch
def greet(a: Dog, b: Cat):
    return "Grrrr..."


# Let's try it out
cat, dog = Cat(), Dog()


print(greet(cat, dog))  # "Hiss!"
print(greet(dog, cat))  # Grrrr...

Hiss!
Grrrr...

# Method 1: Direct functions
def enc_str(x:str): return f"encoded str: {x=}"
def enc_int(x:int): return f"encoded int: {x=}"
my_transform = Transform(enc=(enc_str,enc_int))

my_transform(("hello", 42))

("encoded str: x='hello'", 'encoded int: x=42')

# Method 2: Create a Transform subclass
class MyTransform(Transform):
    def encodes(self, x:str): return f"encoded str: {x=}"
    def encodes(self, x:int): return f"encoded int: {x=}"
    
my_transform = MyTransform()
my_transform(("my str", 42))

("encoded str: x='my str'", 'encoded int: x=42')

# Method 3: Extend with decorators
@MyTransform
def encodes(self, x: float): return f"encoded float: {x=}"

# Now our transform handles three types!
my_transform(("hello", 42, 6.28))  

("encoded str: x='hello'", 'encoded int: x=42', 'encoded float: x=6.28')

# In fastai.data.transforms:
class Normalize(Transform): ...  # handles image normalization

# In fastai.tabular.core:
@Normalize
def encodes(self, x: pd.DataFrame): ...  # adds DataFrame support

pip install fasttransform