转换

我们在前一章学习标记化和数值化时， 我们从抓取一堆文本开始：

files = get_text_files(path, folders = ['train', 'test'])
txts = L(o.open().read() for o in files[:2000])

然后我们展示了如何用Tokenizer

tok = Tokenizer.from_folder(path)
tok.setup(txts)
toks = txts.map(tok)
toks[0]

(#374) ['xxbos','xxmaj','well',',','"','cube','"','(','1997',')'...]

以及如何数值化，包括为我们的语料库自动创建词汇：

num = Numericalize()
num.setup(toks)
nums = toks.map(num)
nums[0][:10]

tensor([   2,    8,   76,   10,   23, 3112,   23,   34, 3113,   33])

这些类也有一个decode方法。例如， Numericalize.decode给我们返回字符串标记：

nums_dec = num.decode(nums[0][:10]); nums_dec

(#10) ['xxbos','xxmaj','well',',','"','cube','"','(','1997',')']

Tokenizer.decode将其变回单个字符串（但是，它可能与原始字符串不完全相同；这取决于分词器是否可逆，而在我们撰写本书时，默认词分词器不是可逆的）：

tok.decode(nums_dec)

'xxbos xxmaj well , "cube" ( 1997 )'

decode由 fastaishow_batch和 show_results以及其他一些推理方法使用，将预测和小批量转换为人类可理解的表示。

对于前面的每个示例tok或num在前面的示例中，我们创建了一个名为setup 方法的对象（如果需要，它会训练分词器tok并为 创建词汇表num），将其应用于我们的原始文本（通过将对象作为函数调用），最后将结果解码回可理解的表示形式。大多数数据预处理任务都需要这些步骤，所以fastai提供了一个类来封装它们。这是 Transform班级。Tokenize和都是s Numericalize。Transform

一般来说，aTransform是一个行为类似于函数的对象，它有一个可选的setup方法来初始化一个内部状态（就像里面的词汇num）和一个可选的decode方法来反转函数（这种反转可能并不完美，正如我们在tok).

一个很好的例子decode是在Normalize我们的变换中在第 7 章 中看到：为了能够绘制图像，它的decode方法取消了归一化（即，它乘以标准偏差并加回平均值）。另一方面，数据增强转换没有decode方法，因为我们想显示对图像的影响以确保数据增强按我们想要的方式工作。

s 的一个特殊行为Transform是它们总是应用于元组。通常，我们的数据总是一个元组(input,target) （有时有多个输入或多个目标）。当对像这样的项目应用转换时Resize，我们不想调整整个元组的大小；相反，我们希望分别调整输入（如果适用）和目标（如果适用）的大小。对于进行数据增强的批处理变换也是如此：当输入是图像并且目标是分割掩码时，需要将变换（以相同的方式）应用于输入和目标。

如果我们将一个文本元组传递给tok：

tok((txts[0], txts[1]))

((#374) ['xxbos','xxmaj','well',',','"','cube','"','(','1997',')'...],
 (#207)
 > ['xxbos','xxmaj','conrad','xxmaj','hall','went','out','with','a','bang'...])

编写自己的转换

如果您想编写一个自定义转换以应用于您的数据，最简单的方法是编写一个函数。正如你在这个例子中看到的，一个 Transform如果提供了类型，将仅应用于匹配类型（否则，它将始终被应用）。在以下代码:int中，函数签名中的 表示f仅应用于ints. 这就是tfm(2.0)returns的原因2.0，但 在这里tfm(2)返回3：

def f(x:int): return x+1
tfm = Transform(f)
tfm(2),tfm(2.0)

(3, 2.0)

在这里，f被转换为一个Transform没有setup和没有decode 方法。

Python 有一种特殊的语法，用于将函数（如f）传递给另一个函数（或行为类似于函数的东西， 在 Python 中称为可调用对象），称为装饰器。装饰器的使用方法是在可调用函数前面加上一个可调用@项并将其放在函数定义之前（有很多关于 Python 装饰器的在线教程，如果这对您来说是一个新概念，请看一看）。以下代码与前面的代码相同：

@Transform
def f(x:int): return x+1
f(2),f(2.0)

(3, 2.0)

如果您需要setup或decode，则需要子类 Transform化以实现 中的实际编码行为encodes，然后（可选）实现中的设置行为setups和 中的解码行为decodes：

class NormalizeMean(Transform):
    def setups(self, items): self.mean = sum(items)/len(items)
    def encodes(self, x): return x-self.mean
    def decodes(self, x): return x+self.mean

这里，NormalizeMean会在setup过程中初始化某个状态（所有元素通过的均值）；那么变换就是减去那个均值。出于解码目的，我们通过添加均值来实现该转换的逆向。这是一个实际的例子NormalizeMean ：

tfm = NormalizeMean()
tfm.setup([1,2,3,4,5])
start = 2
y = tfm(start)
z = tfm.decode(y)
tfm.mean,y,z

(3.0, -1.0, 2.0)

请注意，对于这些方法中的每一个，调用的方法和实现的方法是不同的：

因此，例如，您永远不会setups直接调用，而是调用setup. 原因是setup在调用setups你之前和之后做了一些工作。要了解有关 Transforms 的更多信息以及如何使用它们根据输入类型实现不同的行为，请务必查看 fastai 文档中的教程。

管道

为了将多个转换组合在一起，fastai 提供了这个Pipeline类。我们Pipeline通过将 s 的列表传递给 a 来 定义 a Transform；然后它将在其中组合转换。当你Pipeline在一个对象上调用 a 时，它会自动调用里面的转换，顺序是：

tfms = Pipeline([tok, num])
t = tfms(txts[0]); t[:20]

tensor([   2,    8,   76,   10,   23, 3112,   23,   34, 3113,   33,   10,    8,
 > 4477,   22,   88,   32,   10,   27,   42,   14])

你可以调用decode你的编码结果，取回你可以显示和分析的东西：

tfms.decode(t)[:100]

'xxbos xxmaj well , " cube " ( 1997 ) , xxmaj vincenzo \'s first movie , was one
 > of the most interesti'

唯一与其中工作方式不同的部分 Transform是设置。要在某些数据上正确设置 a Pipelineof Transform，您需要使用 a TfmdLists。

TfmdLists

这是我们在上一节中看到的进行转换的简短方法：

tls = TfmdLists(files, [Tokenizer.from_folder(path), Numericalize])

在初始化时，TfmdLists将自动按顺序调用setup each 的方法，Transform按顺序为每个提供的不是原始项目，而是由所有先前Transforms 转换的项目。我们可以Pipeline通过索引到任何原始元素来获得我们的结果TfmdLists：

t = tls[0]; t[:20]

tensor([    2,     8,    91,    11,    22,  5793,    22,    37,  4910,    34,
 > 11,     8, 13042,    23,   107,    30,    11,    25,    44,    14])

并且TfmdLists知道如何解码以用于展示目的：

tls.decode(t)[:100]

'xxbos xxmaj well , " cube " ( 1997 ) , xxmaj vincenzo \'s first movie , was one
 > of the most interesti'

其实它还有一个show方法：

tls.show(t)

xxbos xxmaj well , " cube " ( 1997 ) , xxmaj vincenzo 's first movie , was one
 > of the most interesting and tricky ideas that xxmaj i 've ever seen when
 > talking about movies . xxmaj they had just one scenery , a bunch of actors
 > and a plot . xxmaj so , what made it so special were all the effective
 > direction , great dialogs and a bizarre condition that characters had to deal
 > like rats in a labyrinth . xxmaj his second movie , " cypher " ( 2002 ) , was
 > all about its story , but it was n't so good as " cube " but here are the
 > characters being tested like rats again .

 " nothing " is something very interesting and gets xxmaj vincenzo coming back
 > to his ' cube days ' , locking the characters once again in a very different
 > space with no time once more playing with the characters like playing with
 > rats in an experience room . xxmaj but instead of a thriller sci - fi ( even
 > some of the promotional teasers and trailers erroneous seemed like that ) , "
 > nothing " is a loose and light comedy that for sure can be called a modern
 > satire about our society and also about the intolerant world we 're living .
 > xxmaj once again xxmaj xxunk amaze us with a great idea into a so small kind
 > of thing . 2 actors and a blinding white scenario , that 's all you got most
 > part of time and you do n't need more than that . xxmaj while " cube " is a
 > claustrophobic experience and " cypher " confusing , " nothing " is
 > completely the opposite but at the same time also desperate .

 xxmaj this movie proves once again that a smart idea means much more than just
 > a millionaire budget . xxmaj of course that the movie fails sometimes , but
 > its prime idea means a lot and offsets any flaws . xxmaj there 's nothing
 > more to be said about this movie because everything is a brilliant surprise
 > and a totally different experience that i had in movies since " cube " .

它TfmdLists以“s”命名，因为它可以处理带有splits参数的训练集和验证集。您只需要传递训练集中元素的索引和验证集中元素的索引：

cut = int(len(files)*0.8)
splits = [list(range(cut)), list(range(cut,len(files)))]
tls = TfmdLists(files, [Tokenizer.from_folder(path), Numericalize],
                splits=splits)

然后您可以通过train和valid属性访问它们：

tls.valid[0][:20]

tensor([    2,     8,    20,    30,    87,   510,  1570,    12,   408,   379,
 > 4196,    10,     8,    20,    30,    16,    13, 12216,   202,   509])

如果您手动编写了一次Transform执行所有预处理的程序，将原始项目转换为包含输入和目标的元组，TfmdLists那么 你需要的课程。您可以使用 方法将其直接转换为DataLoaders对象dataloaders。这就是我们将在本章后面的连体示例中做的事情。

不过，一般来说，您将有两个（或更多）并行的转换管道：一个用于将原始项目处理为输入，另一个用于将原始项目处理为目标。例如，在这里，我们定义的管道仅将原始文本处理为输入。如果我们要做文本分类，我们还必须将标签处理成 目标。

为此，我们需要做两件事。首先，我们从父文件夹中获取标签名称。parent_label为此，有一个函数：

lbls = files.map(parent_label)
lbls

(#50000) ['pos','pos','pos','pos','pos','pos','pos','pos','pos','pos'...]

然后我们需要一个Transform在设置过程中获取独特项目并用它们构建词汇表的工具，然后在调用时将字符串标签转换为整数。fastai 为我们提供了这个；它被称为Categorize：

cat = Categorize()
cat.setup(lbls)
cat.vocab, cat(lbls[0])

((#2) ['neg','pos'], TensorCategory(1))

要在我们的文件列表中自动完成整个设置，我们可以TfmdLists像以前一样创建一个：

tls_y = TfmdLists(files, [parent_label, Categorize()])
tls_y[0]

TensorCategory(1)

但是我们最终会得到两个单独的对象作为输入和目标，这不是我们想要的。这是Datasets救援的地方。

数据集

Datasets将对同一个原始对象并行应用两个（或更多）管道，并用结果构建一个元组。就像TfmdLists，它会 自动为我们进行设置，当我们索引到 a 时Datasets，它会返回一个包含每个管道结果的元组：

x_tfms = [Tokenizer.from_folder(path), Numericalize]
y_tfms = [parent_label, Categorize()]
dsets = Datasets(files, [x_tfms, y_tfms])
x,y = dsets[0]
x[:20],y

像 a 一样TfmdLists，我们可以传递splits给 aDatasets以在训练集和验证集之间拆分我们的数据：

x_tfms = [Tokenizer.from_folder(path), Numericalize]
y_tfms = [parent_label, Categorize()]
dsets = Datasets(files, [x_tfms, y_tfms], splits=splits)
x,y = dsets.valid[0]
x[:20],y

(tensor([    2,     8,    20,    30,    87,   510,  1570,    12,   408,   379,
 > 4196,    10,     8,    20,    30,    16,    13, 12216,   202,   509]),
 TensorCategory(0))

它还可以解码任何处理过的元组或直接显示它：

t = dsets.valid[0]
dsets.decode(t)

('xxbos xxmaj this movie had horrible lighting and terrible camera movements .
 > xxmaj this movie is a jumpy horror flick with no meaning at all . xxmaj the
 > slashes are totally fake looking . xxmaj it looks like some 17 year - old
 > idiot wrote this movie and a 10 year old kid shot it . xxmaj with the worst
 > acting you can ever find . xxmaj people are tired of knives . xxmaj at least
 > move on to guns or fire . xxmaj it has almost exact lines from " when a xxmaj
 > stranger xxmaj calls " . xxmaj with gruesome killings , only crazy people
 > would enjoy this movie . xxmaj it is obvious the writer does n\'t have kids
 > or even care for them . i mean at show some mercy . xxmaj just to sum it up ,
 > this movie is a " b " movie and it sucked . xxmaj just for your own sake , do
 > n\'t even think about wasting your time watching this crappy movie .',
 'neg')

最后一步是将我们的Datasets对象转换为 a DataLoaders，这可以通过dataloaders方法来完成。这里我们需要传递一个特殊的参数来处理填充问题（正如我们在前一章中看到的）。这需要在我们批处理元素之前发生，所以我们将它传递给before_batch：

dls = dsets.dataloaders(bs=64, before_batch=pad_input)

dataloaders直接调用DataLoader我们的每个子集 Datasets。fastai DataLoader扩展了同名的 PyTorch 类，并负责将我们数据集中的项目整理成批次。它有很多定制点，但您应该了解的最重要的点如下：

after_item

在数据集中抓取每个项目后应用于每个项目。这相当于item_tfms在DataBlock.

before_batch

在整理之前应用于项目列表。这是将物品填充到相同尺寸的理想位置。

after_batch

施工后应用于整个批次。这相当于batch_tfms在DataBlock.

作为结论，这里是为文本 分类准备数据所需的完整代码：

tfms = [[Tokenizer.from_folder(path), Numericalize], [parent_label, Categorize]]
files = get_text_files(path, folders = ['train', 'test'])
splits = GrandparentSplitter(valid_name='test')(files)
dsets = Datasets(files, tfms, splits=splits)
dls = dsets.dataloaders(dl_type=SortedDL, before_batch=pad_input)

与之前代码的两个不同之处在于使用 GrandparentSplitter来拆分我们的训练和验证数据，以及 dl_type参数。这是告诉 dataloaders使用SortedDL 类DataLoader，而不是通常的类。SortedDL通过将大致相同长度的样本放入批次中来构建批次。

这与我们之前的完全相同DataBlock：

path = untar_data(URLs.IMDB)
dls = DataBlock(
    blocks=(TextBlock.from_folder(path),CategoryBlock),
    get_y = parent_label,
    get_items=partial(get_text_files, folders=['train', 'test']),
    splitter=GrandparentSplitter(valid_name='test')
).dataloaders(path)

但现在您知道如何自定义它的每一部分了！

现在让我们在计算机视觉示例上练习我们刚刚学到的使用这个中级 API 进行数据预处理的知识。