speechbrain.utils.data_pipeline 模块

数据转换的管道。

Example

>>> from hyperpyyaml import load_hyperpyyaml
>>> yamlstring = '''
... pipeline: !new:speechbrain.utils.data_pipeline.DataPipeline
...     static_data_keys: [a, b]
...     dynamic_items:
...         -   func: !name:operator.add
...             takes: ["a", "b"]
...             provides: foo
...         -   func: !name:operator.sub
...             takes: ["foo", "b"]
...             provides: bar
...     output_keys: ["foo", "bar"]
... '''
>>> hparams = load_hyperpyyaml(yamlstring)
>>> hparams["pipeline"]({"a":1, "b":2})
{'foo': 3, 'bar': 1}

Author:

• 阿库·柔荷

摘要

类：

DataPipeline	将数据转换组织成一个管道。
DynamicItem	本质上代表一个数据转换函数。
GeneratorDynamicItem	本质上代表了一个多步骤的数据转换。
StaticItem	表示静态项的数据类。

函数：

provides	装饰器，用于创建一个DynamicItem并指定它提供的键。
provides_decorator	装饰器，用于创建一个DynamicItem并指定它提供的键。
takes	装饰器，用于创建一个DynamicItem并指定其argkeys。
takes_decorator	装饰器，用于创建一个DynamicItem并指定其argkeys。

参考

class speechbrain.utils.data_pipeline.StaticItem(key: str)

基础类：object

表示静态项目的数据类。

静态项目是内存中的项目，因此它们不需要动态计算。

key: str

class speechbrain.utils.data_pipeline.DynamicItem(takes=[], func=None, provides=[])

基础类：object

本质上代表一个数据转换函数。

DynamicItem 接受一些参数，并在调用时动态计算其值。一个直接的用例是从磁盘动态加载某些内容；获取路径并提供加载的数据。

此类的实例通常通过@takes和@provides装饰器隐式创建，或者通过指定所需的参数和提供的参数以及函数来创建。

对应的是 GeneratorDynamicItem，它应该用于生成器函数。

Parameters:

• 需要 (列表) – 计算输出所需的项目键。

• func (callable) – 用于计算输出的函数。

• 提供 (列表) – 此提供的键。

next_takes()

当调用时，要提供给此的下一个argkeys。

next_provides()

当调用时，此函数提供的下一个键。

provided_in_order()

假设这可能需要被多次调用；在每次调用时它提供哪些键。返回一个列表，其长度等于可能被调用的次数。

reset()

表示在此管道调用上将不再调用此信号。

class speechbrain.utils.data_pipeline.GeneratorDynamicItem(*args, **kwargs)

基础类: DynamicItem

本质上代表了一个多步骤的数据转换。

这是DynamicItem的生成器函数对应物（应该用于常规函数）。

GeneratorDynamicItem 首先接受一些参数，然后在调用时使用这些参数通过多个步骤逐步计算一些值。

一个典型的用例是数据转换的管道：例如，将文本作为字符串输入，首先生成一个分词版本，然后在第二次调用时提供一个整数编码版本。即使整数编码器需要在第一次输出上进行训练，也可以使用这种方法。

主要的好处是能够在一个清晰的函数中定义管道，即使管道的某些部分依赖于其他部分的初始化。

Parameters:

• *args (tuple) – 转发到父类

• **kwargs (tuple) – 转发到父类

Example

>>> lab2ind = {}
>>> def text_pipeline(text):
...     text = text.lower().strip()
...     text = "".join(c for c in text if c.isalpha() or c == " ")
...     words = text.split()
...     yield words
...     encoded = [lab2ind[word] for word in words]
...     yield encoded
>>> item = GeneratorDynamicItem(
...         func=text_pipeline,
...         takes=["text"],
...         provides=["words", "words_encoded"])
>>> # First create the integer-encoding:
>>> ind = 1
>>> for token in item("Is this it? - This is it."):
...     if token not in lab2ind:
...         lab2ind[token] = ind
...         ind += 1
>>> # Now the integers can be encoded!
>>> item()
[1, 2, 3, 2, 1, 3]

next_takes()

当调用时，要提供给此的下一个argkeys。

next_provides()

当调用时，此函数提供的下一个键。

provided_in_order()

假设这可能需要被多次调用；在每次调用时它提供哪些键。返回一个列表，其长度等于可能被调用的次数。

reset()

表示在此管道调用上将不再调用此信号。

speechbrain.utils.data_pipeline.takes(*argkeys)

装饰器，用于创建一个DynamicItem并指定其argkeys。

如果包装的对象是一个生成器函数（包含 yield 语句）， 则创建一个 GeneratorDynamicItem。如果对象已经是一个 DynamicItem， 则只需为其指定 argkeys。否则，创建一个新的常规 DynamicItem，并指定 argkeys。

参数总是在开始时传递给函数。生成器可以支持发送新参数，但对于此类用例，只需创建一个新的动态项。GeneratorDynamicItem 类适用于接收输入并以多种方式转换它的管道，其中可能需要中间表示，例如用于拟合 BPE 分词器。

Parameters:

*argkeys (tuple) – 预期作为输入的数据键

Return type:

装饰后的函数，指定了输入参数

Example

>>> @takes("text")
... def tokenize(text):
...     return text.strip().lower().split()
>>> tokenize.provides = ["tokenized"]
>>> tokenize('      This Example gets tokenized')
['this', 'example', 'gets', 'tokenized']

speechbrain.utils.data_pipeline.takes_decorator(*argkeys)

装饰器，用于创建一个DynamicItem并指定其argkeys。

如果包装的对象是一个生成器函数（包含 yield 语句），则创建一个 GeneratorDynamicItem。如果对象已经是一个 DynamicItem，则只需为其指定 argkeys。否则，创建一个新的常规 DynamicItem，并指定 argkeys。

参数总是在开始时传递给函数。生成器可以支持发送新参数，但对于此类用例，只需创建一个新的动态项。GeneratorDynamicItem 类适用于接收输入并以多种方式转换它的管道，其中可能需要中间表示，例如用于拟合 BPE 分词器。

Parameters:

*argkeys (tuple) – 预期作为输入的数据键

Return type:

装饰后的函数，指定了输入参数

Example

>>> @takes("text")
... def tokenize(text):
...     return text.strip().lower().split()
>>> tokenize.provides = ["tokenized"]
>>> tokenize('      This Example gets tokenized')
['this', 'example', 'gets', 'tokenized']

speechbrain.utils.data_pipeline.provides(*output_keys)

装饰器，用于创建一个DynamicItem并指定它提供的键。

如果包装的对象是一个生成器函数（包含 yield 语句）， 则创建一个 GeneratorDynamicItem。如果对象已经是一个 DynamicItem， 则仅为该对象指定提供的键。否则，创建一个新的常规 DynamicItem，并指定提供的键。

Parameters:

*output_keys (tuple) – 该函数将生成的数据键

Return type:

装饰后的函数，指定了输出键

注意

对于生成器和常规函数，行为略有不同，如果指定了许多输出键，例如 @provides(“signal”, “mfcc”)。常规函数应返回一个长度等于 len(output_keys) 的元组，而生成器应逐个生成项目。

>>> @provides("signal", "feat")
... def read_feat():
...     wav = [.1,.2,-.1]
...     feat = [s**2 for s in wav]
...     return wav, feat
>>> @provides("signal", "feat")
... def read_feat():
...     wav = [.1,.2,-.1]
...     yield wav
...     feat = [s**2 for s in wav]
...     yield feat

如果同时生成多个键，请写入例如，

>>> @provides("wav_read", ["left_channel", "right_channel"])
... def read_multi_channel():
...     wav = [[.1,.2,-.1],[.2,.1,-.1]]
...     yield wav
...     yield wav[0], wav[1]

speechbrain.utils.data_pipeline.provides_decorator(*output_keys)

装饰器，用于创建一个DynamicItem并指定它提供的键。

如果包装的对象是一个生成器函数（包含 yield 语句），则创建一个 GeneratorDynamicItem。如果对象已经是一个 DynamicItem，则仅为该对象指定提供的键。否则，创建一个新的常规 DynamicItem，并指定提供的键。

Parameters:

*output_keys (tuple) – 该函数将生成的数据键

Return type:

装饰后的函数，指定了输出键

注意

对于生成器和常规函数，行为略有不同，如果指定了许多输出键，例如@provides(“signal”, “mfcc”)。常规函数应返回一个长度等于len(output_keys)的元组，而生成器应逐个生成项目。

>>> @provides("signal", "feat")
... def read_feat():
...     wav = [.1,.2,-.1]
...     feat = [s**2 for s in wav]
...     return wav, feat
>>> @provides("signal", "feat")
... def read_feat():
...     wav = [.1,.2,-.1]
...     yield wav
...     feat = [s**2 for s in wav]
...     yield feat

如果同时生成多个键，请写入例如，

>>> @provides("wav_read", ["left_channel", "right_channel"])
... def read_multi_channel():
...     wav = [[.1,.2,-.1],[.2,.1,-.1]]
...     yield wav
...     yield wav[0], wav[1]

class speechbrain.utils.data_pipeline.DataPipeline(static_data_keys, dynamic_items=[], output_keys=[])

基础类：object

将数据转换组织成一个管道。

Parameters:

• static_data_keys (list) – 作为数据提供的键

• dynamic_items (list) – 一个包含“func”、“takes”和“provides”的映射列表

• output_keys (list) – 用作输出的键

Example

>>> pipeline = DataPipeline(
...     static_data_keys=["text"],
...     dynamic_items=[
...     {"func": lambda x: x.lower(), "takes": "text", "provides": "foo"},
...     {"func": lambda x: x[::-1], "takes": "foo", "provides": "bar"},
...     ],
...     output_keys=["bar"],
... )
>>> pipeline({"text": "Test"})
{'bar': 'tset'}

add_static_keys(static_keys)

通知管道有关静态项目的信息。

静态项是作为数据提供给 __call__ 的项。

add_dynamic_items(dynamic_items)

一次性添加多个动态项目。

add_dynamic_item(func, takes=None, provides=None)

向管道添加一个动态项。

两种调用约定。对于DynamicItem对象，只需使用： add_dynamic_item(dynamic_item) 但除此之外，应该使用： add_dynamic_item(func, takes, provides)

Parameters:

• func (callable, DynamicItem) – 如果提供了 DynamicItem，则直接添加。否则，创建一个 DynamicItem，并指定要使用的可调用对象。如果提供了生成器函数，则创建一个 GeneratorDynamicItem。否则，创建一个普通的 DynamicItem。

• takes (list, str) – 键的列表。当调用 func 时，每个键会被解析为数据中的条目或另一个 dynamic_item 的输出。然后，func 会以这些作为位置参数调用，顺序与此处指定的顺序相同。单个键可以作为裸字符串给出。

• 提供 (str, list) – 对于常规函数，它提供的键或键列表。 如果你给出一个生成器函数，它按顺序生成的键或键列表。 也可以参考provides装饰器。 单个键可以作为裸字符串给出。

Return type:

无

set_output_keys(keys)

使用此功能来更改输出键。

还会重新评估执行顺序。 因此，如果您请求不同的输出，数据管道的某些部分可能会被跳过。

Parameters:

keys (dict, list, None) –

要在输出中生成的键（str）列表。

如果给定了一个字典；它用于将内部键映射到输出键。 从output_keys字典的键值对中，键出现在外部， 值是内部键。

compute_outputs(data)

Parameters:

data (dict) – 按键存储数据条目的字典。

Returns:

使用已设置的键。

Return type:

dict

compute_specific(keys, data)

计算特定项目的输出，而不改变output_keys。

get_selected_node_ids(selected_keys)

将选定的键转换为依赖图键。