主要类别

DatasetInfo

class datasets.DatasetInfo

( description: str = <factory> citation: str = <factory> homepage: str = <factory> license: str = <factory> features: Optional = None post_processed: Optional = None supervised_keys: Optional = None builder_name: Optional = None dataset_name: Optional = None config_name: Optional = None version: Union = None splits: Optional = None download_checksums: Optional = None download_size: Optional = None post_processing_size: Optional = None dataset_size: Optional = None size_in_bytes: Optional = None )

参数

description (str) — 数据集的描述。
citation (str) — 数据集的 BibTeX 引用。
homepage (str) — 数据集官方主页的 URL。
license (str) — 数据集的许可证。可以是许可证的名称，也可以是包含许可证条款的段落。
features (Features, 可选) — 用于指定数据集列类型的特征。
post_processed (PostProcessedInfo, 可选) — 关于数据集可能进行的后处理资源的信息。例如，它可以包含索引的信息。
supervised_keys (SupervisedKeysData, 可选) — 如果数据集适用于监督学习，则指定输入特征和标签 (TFDS 的遗留)。
builder_name (str, 可选) — 用于创建数据集的 GeneratorBasedBuilder 子类的名称。通常与相应的脚本名称匹配。它也是数据集构建器类名称的 snake_case 版本。
config_name (str, 可选) — 从 BuilderConfig 派生的配置名称。
version (str 或 Version, 可选) — 数据集的版本。
splits (dict, 可选) — 分割名称和元数据之间的映射。
download_checksums (dict, 可选) — 下载数据集校验和的 URL 与相应元数据之间的映射。
download_size (int, 可选) — 生成数据集需要下载的文件大小，以字节为单位。
post_processing_size (int, 可选) — 后处理后数据集的大小（以字节为单位），如果有的话。
dataset_size (int, 可选) — 所有分割的 Arrow 表的总大小（以字节为单位）。
size_in_bytes (int, 可选) — 与数据集关联的所有文件（下载的文件 + Arrow 文件）的总大小（以字节为单位）。
**config_kwargs** (additional keyword arguments) — 要传递给 BuilderConfig 并在 DatasetBuilder 中使用的关键字参数。

关于数据集的信息。

DatasetInfo 记录数据集，包括其名称、版本和特征。有关完整列表，请参阅构造函数参数和属性。

并非所有字段在构造时都是已知的，可能会在以后更新。

from_directory
< source >
( dataset_info_dir: str storage_options: Optional = None )

参数

dataset_info_dir (str) — 包含元数据文件的目录。这应该是特定数据集版本的根目录。
storage_options (dict, optional) — 要传递给文件系统后端的键/值对（如果有）。

在 2.9.0 版本中添加

从 dataset_info_dir 中的 JSON 文件创建 DatasetInfo。

此函数更新 DatasetInfo 的所有动态生成的字段（num_examples、hash、创建时间等）。

这将覆盖所有先前的元数据。

示例

>>> from datasets import DatasetInfo >>> ds_info = DatasetInfo.from_directory("/path/to/directory/")

write_to_directory
< source >
( dataset_info_dir pretty_print = False storage_options: Optional = None )

参数

dataset_info_dir (str) — 目标目录。
pretty_print (bool, 默认为 False) — 如果为 True，JSON 将以 4 个缩进级别进行美观打印。
storage_options (dict, optional) — 要传递给文件系统后端的键/值对（如果有）。

在 2.9.0 版本中添加

将 DatasetInfo 和许可证（如果存在）作为 JSON 文件写入 dataset_info_dir。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.info.write_to_directory("/path/to/directory/")

Dataset

基类 Dataset 实现了一个由 Apache Arrow 表支持的 Dataset。

class datasets.Dataset
< source >
( arrow_table: Table info: Optional = None split: Optional = None indices_table: Optional = None fingerprint: Optional = None )

一个由 Arrow 表支持的 Dataset。

add_column
< source >
( name: str column: Union new_fingerprint: str feature: Union = None )

参数

name (str) — 列名。
column (list 或 np.array) — 要添加的列数据。
feature (FeatureType 或 None, 默认为 None) — 列数据类型。

向 Dataset 添加列。

在 1.7 版本中添加

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> more_text = ds["text"] >>> ds.add_column(name="text_2", column=more_text) Dataset({ features: ['text', 'label', 'text_2'], num_rows: 1066 })

add_item
< source >
( item: dict new_fingerprint: str )

参数

item (dict) — 要添加的项目数据。

向 Dataset 添加项目。

在 1.7 版本中添加

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> new_review = {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'} >>> ds = ds.add_item(new_review) >>> ds[-1] {'label': 0, 'text': 'this movie is the absolute worst thing I have ever seen'}

from_file
< source >
( filename: str info: Optional = None split: Optional = None indices_filename: Optional = None in_memory: bool = False )

参数

filename (str) — 数据集的文件名。
info (DatasetInfo, optional) — 数据集信息，如描述、引文等。
split (NamedSplit, optional) — 数据集拆分的名称。
indices_filename (str, optional) — 索引的文件名。
in_memory (bool, 默认为 False) — 是否将数据复制到内存中。

实例化一个由文件名处的 Arrow 表支持的 Dataset。

from_buffer
< source >
( buffer: Buffer info: Optional = None split: Optional = None indices_buffer: Optional = None )

参数

buffer (pyarrow.Buffer) — Arrow 缓冲区。
info (DatasetInfo, optional) — 数据集信息，如描述、引文等。
split (NamedSplit, optional) — 数据集拆分的名称。
indices_buffer (pyarrow.Buffer, optional) — 索引 Arrow 缓冲区。

实例化一个由 Arrow 缓冲区支持的 Dataset。

from_pandas
< source >
( df: DataFrame features: Optional = None info: Optional = None split: Optional = None preserve_index: Optional = None )

参数

df (pandas.DataFrame) — 包含数据集的 Dataframe。
features (Features, 可选) — 数据集特征。
info (DatasetInfo, 可选) — 数据集信息，例如描述、引用等。
split (NamedSplit, 可选) — 数据集拆分的名称。
preserve_index (bool, 可选) — 是否将索引存储为结果 Dataset 中的附加列。默认值 None 将索引存储为列，但 RangeIndex 除外，后者仅存储为元数据。使用 preserve_index=True 强制将其存储为列。

将 pandas.DataFrame 转换为 pyarrow.Table 以创建一个 Dataset。

结果 Arrow Table 中的列类型是从 DataFrame 中 pandas.Series 的 dtype 推断出来的。对于非对象 Series，NumPy dtype 将转换为其 Arrow 等效类型。对于 object，我们需要通过查看此 Series 中的 Python 对象来猜测数据类型。

请注意，object dtype 的 Series 没有携带足够的信息来始终产生有意义的 Arrow 类型。在我们无法推断类型的情况下，例如，因为 DataFrame 的长度为 0 或 Series 仅包含 None/nan 对象，则类型设置为 null。可以通过构造显式特征并将其传递给此函数来避免此行为。

示例

>>> ds = Dataset.from_pandas(df)

from_dict
< source >
( mapping: dict features: Optional = None info: Optional = None split: Optional = None )

参数

mapping (Mapping) — 字符串到数组或 Python 列表的映射。
features (Features, 可选) — 数据集特征。
info (DatasetInfo, 可选) — 数据集信息，例如描述、引用等。
split (NamedSplit, 可选) — 数据集拆分的名称。

将 dict 转换为 pyarrow.Table 以创建一个 Dataset。

from_generator
< source >
( generator: Callable features: Optional = None cache_dir: str = None keep_in_memory: bool = False gen_kwargs: Optional = None num_proc: Optional = None split: NamedSplit = NamedSplit('train') **kwargs )

参数

generator ( —Callable): 一个生成器函数，用于 yields 示例。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
gen_kwargs(dict, 可选) — 要传递给 generator 可调用对象的关键字参数。您可以通过在 gen_kwargs 中传递分片列表并将 num_proc 设置为大于 1 来定义分片数据集。
num_proc (int, 可选, 默认为 None) — 本地下载和生成数据集时使用的进程数。如果数据集由多个文件组成，这将很有帮助。默认情况下禁用多进程处理。如果 num_proc 大于 1，则 gen_kwargs 中的所有列表值必须具有相同的长度。这些值将在对生成器的调用之间进行拆分。分片数将是 gen_kwargs 中最短列表和 num_proc 的最小值。

在 2.7.0 中添加

split (NamedSplit, 默认为 Split.TRAIN) — 要分配给数据集的拆分名称。

在 2.21.0 中添加

**kwargs (附加关键字参数) — 要传递给 :GeneratorConfig 的关键字参数。

从生成器创建一个 Dataset。

示例

>>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = Dataset.from_generator(gen)

>>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = Dataset.from_generator(gen, gen_kwargs={"shards": shards})

data
< source >
( )

支持数据集的 Apache Arrow 表。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.data MemoryMappedTable text: string label: int64 ---- text: [["compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .","the soundtrack alone is worth the price of admission .","rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .","beneath the film's obvious determination to shock at any cost lies considerable skill and determination , backed by sheer nerve .","bielinsky is a filmmaker of impressive talent .","so beautifully acted and directed , it's clear that washington most certainly has a new career ahead of him if he so chooses .","a visual spectacle full of stunning images and effects .","a gentle and engrossing character study .","it's enough to watch huppert scheming , with her small , intelligent eyes as steady as any noir villain , and to enjoy the perfectly pitched web of tension that chabrol spins .","an engrossing portrait of uncompromising artists trying to create something original against the backdrop of a corporate music industry that only seems to care about the bottom line .",...,"ultimately , jane learns her place as a girl , softens up and loses some of the intensity that made her an interesting character to begin with .","ah-nuld's action hero days might be over .","it's clear why deuces wild , which was shot two years ago , has been gathering dust on mgm's shelf .","feels like nothing quite so much as a middle-aged moviemaker's attempt to surround himself with beautiful , half-naked women .","when the precise nature of matthew's predicament finally comes into sharp focus , the revelation fails to justify the build-up .","this picture is murder by numbers , and as easy to be bored by as your abc's , despite a few whopping shootouts .","hilarious musical comedy though stymied by accents thick as mud .","if you are into splatter movies , then you will probably have a reasonably good time with the salton sea .","a dull , simple-minded and stereotypical tale of drugs , death and mind-numbing indifference on the inner-city streets .","the feature-length stretch . . . strains the show's concept ."]] label: [[1,1,1,1,1,1,1,1,1,1,...,0,0,0,0,0,0,0,0,0,0]]

cache_files
< source >
( )

包含支持数据集的 Apache Arrow 表的缓存文件。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.cache_files [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}]

num_columns
< source >
( )

数据集中的列数。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.num_columns 2

num_rows
< source >
( )

数据集中的行数（与 Dataset.len() 相同）。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.num_rows 1066

column_names
< source >
( )

数据集中的列名。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.column_names ['text', 'label']

shape
< source >
( )

数据集的形状（列数，行数）。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.shape (1066, 2)

unique
< source >
( column: str ) → list

参数

column (str) — 列名（使用 column_names 列出所有列名）。

返回值

list

给定列中唯一元素的列表。

返回列中唯一元素的列表。

这是在底层后端实现的，因此速度非常快。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.unique('label') [1, 0]

flatten
< source >
( new_fingerprint: Optional = None max_depth = 16 ) → Dataset

参数

new_fingerprint (str, 可选) — 转换后数据集的新指纹。如果为 None，则使用先前指纹的哈希和转换参数计算新指纹。

返回值

Dataset

数据集的副本，其中列已展平。

展平表格。具有 struct 类型的每一列都会被展平为每个 struct 字段一列。其他列保持不变。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("squad", split="train") >>> ds.features {'answers': Sequence(feature={'text': Value(dtype='string', id=None), 'answer_start': Value(dtype='int32', id=None)}, length=-1, id=None), 'context': Value(dtype='string', id=None), 'id': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None), 'title': Value(dtype='string', id=None)} >>> ds.flatten() Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 })

cast
< source >
( features: Features batch_size: Optional = 1000 keep_in_memory: bool = False load_from_cache_file: Optional = None cache_file_name: Optional = None writer_batch_size: Optional = 1000 num_proc: Optional = None ) → Dataset

参数

features (Features) — 要将数据集转换为的新特征。特征中的字段名称必须与当前的列名匹配。数据类型也必须可以从一种类型转换为另一种类型。对于非平凡的转换，例如 str <-> ClassLabel，您应该使用 map() 来更新数据集。
batch_size (int, 默认为 1000) — 每次提供给 cast 的示例数。如果 batch_size <= 0 或 batch_size == None，则将完整数据集作为单个批次提供给 cast。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
load_from_cache_file (bool, 如果启用了缓存，则默认为 True) — 如果可以识别出存储来自 function 的当前计算的缓存文件，则使用它而不是重新计算。
cache_file_name (str, 可选, 默认为 None) — 提供缓存文件的路径名称。它用于存储计算结果，而不是自动生成的缓存文件名。
writer_batch_size (int, 默认为 1000) — 缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间的良好折衷方案。值越高，处理执行的查找次数越少；值越低，在运行 map() 时消耗的临时内存越少。
num_proc (int, 可选, 默认为 None) — 用于多处理的进程数。默认情况下，它不使用多处理。

返回值

Dataset

数据集的副本，其中特征已转换。

将数据集转换为一组新的特征。

示例

>>> from datasets import load_dataset, ClassLabel, Value >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> new_features = ds.features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='large_string', id=None)}

cast_column
< source >
( column: str feature: Union new_fingerprint: Optional = None )

参数

column (str) — 列名。
feature (FeatureType) — 目标特征。
new_fingerprint (str, 可选) — 转换后数据集的新指纹。如果为 None，则使用先前指纹的哈希和转换参数计算新指纹。

将列转换为特征以进行解码。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds.features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='string', id=None)}

remove_columns
< source >
( column_names: Union new_fingerprint: Optional = None ) → Dataset

参数

column_names (Union[str, List[str]]) — 要删除的列的名称。
new_fingerprint (str, 可选) — 转换后数据集的新指纹。如果为 None，则使用先前指纹的哈希和转换参数计算新指纹。

返回值

Dataset

不包含要删除的列的数据集对象的副本。

删除数据集中的一列或多列以及与之关联的特征。

您也可以使用 map() 和 remove_columns 删除列，但当前方法不复制剩余列的数据，因此速度更快。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds = ds.remove_columns('label') Dataset({ features: ['text'], num_rows: 1066 }) >>> ds = ds.remove_columns(column_names=ds.column_names) # Removing all the columns returns an empty dataset with the `num_rows` property set to 0 Dataset({ features: [], num_rows: 0 })

rename_column
< source >
( original_column_name: str new_column_name: str new_fingerprint: Optional = None ) → Dataset

参数

original_column_name (str) — 要重命名的列的名称。
new_column_name (str) — 列的新名称。
new_fingerprint (str, 可选) — 转换后数据集的新指纹。如果为 None，则使用先前指纹的哈希和转换参数计算新指纹。

返回值

Dataset

数据集的副本，其中一列已重命名。

重命名数据集中的一列，并将与原始列关联的特征移动到新列名下。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds = ds.rename_column('label', 'label_new') Dataset({ features: ['text', 'label_new'], num_rows: 1066 })

rename_columns
< source >
( column_mapping: Dict new_fingerprint: Optional = None ) → Dataset

参数

column_mapping (Dict[str, str]) — 列的映射，用于将列重命名为新的名称
new_fingerprint (str, optional) — 转换后数据集的新指纹。如果为 None，则新指纹通过前一个指纹的哈希值和转换参数计算得出。

返回值

Dataset

数据集的副本，其中列已重命名

重命名数据集中的多个列，并将与原始列关联的特征移动到新的列名下。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds = ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 })

select_columns
< source >
( column_names: Union new_fingerprint: Optional = None ) → Dataset

参数

column_names (Union[str, List[str]]) — 要保留的列的名称。
new_fingerprint (str, optional) — 转换后数据集的新指纹。如果为 None，则新指纹通过前一个指纹的哈希值和转换参数计算得出。

返回值

Dataset

数据集对象的副本，仅包含选定的列。

选择数据集中的一个或多个列以及与其关联的特征。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.select_columns(['text']) Dataset({ features: ['text'], num_rows: 1066 })

class_encode_column
< source >
( column: str include_nulls: bool = False )

参数

column (str) — 要转换类型的列的名称（使用 column_names 列出所有列名）
include_nulls (bool, 默认为 False) — 是否在类别标签中包含空值。如果为 True，则空值将被编码为 "None" 类别标签。

在 1.14.2 版本中添加

将给定的列转换为 ClassLabel 并更新表。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("boolq", split="validation") >>> ds.features {'answer': Value(dtype='bool', id=None), 'passage': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None)} >>> ds = ds.class_encode_column('answer') >>> ds.features {'answer': ClassLabel(num_classes=2, names=['False', 'True'], id=None), 'passage': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None)}

__len__
< source >
( )

数据集中的行数。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.__len__ <bound method Dataset.__len__ of Dataset({ features: ['text', 'label'], num_rows: 1066 })>

__iter__
< source >
( )

遍历示例。

如果使用 Dataset.set_format() 设置了格式，则将以选定的格式返回行。

iter
< source >
( batch_size: int drop_last_batch: bool = False )

参数

batch_size (int) — 要生成的每个批次的大小。
drop_last_batch (bool, 默认值 False) — 是否应删除小于 batch_size 的最后一个批次

遍历大小为 batch_size 的批次。

如果使用 [~datasets.Dataset.set_format] 设置了格式，则将以选定的格式返回行。

formatted_as
< source >
( type: Optional = None columns: Optional = None output_all_columns: bool = False **format_kwargs )

参数

type (str, optional) — 在 [None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax'] 中选择的输出类型。None 表示 `getitem“ 返回 python 对象（默认）。
columns (List[str], optional) — 要在输出中格式化的列。 None 表示 __getitem__ 返回所有列（默认）。
output_all_columns (bool, 默认为 False) — 在输出中同时保留未格式化的列（作为 python 对象）。
**format_kwargs (附加关键字参数) — 传递给转换函数的关键字参数，例如 np.array、torch.tensor 或 tensorflow.ragged.constant。

用于 with 语句中。设置 __getitem__ 返回格式（类型和列）。

set_format
< source >
( type: Optional = None columns: Optional = None output_all_columns: bool = False **format_kwargs )

参数

type (str, optional) — 在 [None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax'] 中选择的输出类型。None 表示 __getitem__ 返回 python 对象（默认）。
columns (List[str], optional) — 要在输出中格式化的列。 None 表示 __getitem__ 返回所有列（默认）。
output_all_columns (bool, 默认为 False) — 在输出中同时保留未格式化的列（作为 python 对象）。
**format_kwargs (附加关键字参数) — 传递给转换函数的关键字参数，例如 np.array、torch.tensor 或 tensorflow.ragged.constant。

设置 __getitem__ 返回格式（类型和列）。数据格式化是即时应用的。格式 type （例如 “numpy”）用于在使用 __getitem__ 时格式化批次。也可以使用自定义转换进行格式化，使用 set_transform()。

可以在调用 set_format 后调用 map()。由于 map 可能会添加新列，因此格式化列的列表

会被更新。在这种情况下，如果在数据集上应用 map 以添加新列，则此列将被格式化为

new formatted columns = (all columns - previously unformatted columns)

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['text', 'label']) >>> ds.format {'type': 'numpy', 'format_kwargs': {}, 'columns': ['text', 'label'], 'output_all_columns': False}

set_transform
< source >
( transform: Optional columns: Optional = None output_all_columns: bool = False )

参数

transform (Callable, optional) — 用户定义的格式化转换，替换由 set_format() 定义的格式。格式化函数是一个可调用对象，它接受一个批次（作为 dict）作为输入并返回一个批次。此函数在 __getitem__ 中返回对象之前立即应用。
columns (List[str], optional) — 要在输出中格式化的列。如果指定，则转换的输入批次仅包含这些列。
output_all_columns (bool, 默认为 False) — 在输出中同时保留未格式化的列（作为 python 对象）。如果设置为 True，则其他未格式化的列将与转换的输出一起保留。

使用此转换设置 __getitem__ 返回格式。当调用 __getitem__ 时，转换会即时应用于批次。与 set_format() 类似，可以使用 reset_format() 重置此格式。

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased') >>> def encode(batch): ... return tokenizer(batch['text'], padding=True, truncation=True, return_tensors='pt') >>> ds.set_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 29353, 2135, 15102, 1996, 9428, 20868, 2890, 8663, 6895, 20470, 2571, 3663, 2090, 4603, 3017, 3008, 1998, 2037, 24211, 5637, 1998, 11690, 2336, 1012, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}

reset_format
< source >
( )

将 __getitem__ 返回格式重置为 Python 对象和所有列。

与 self.set_format() 相同

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.set_format(type='numpy', columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds.format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None}

with_format
< source >
( type: Optional = None columns: Optional = None output_all_columns: bool = False **format_kwargs )

参数

type (str, 可选) — 在 [None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax'] 中选择的输出类型。None 表示 __getitem__ 返回 Python 对象（默认）。
columns (List[str], 可选) — 要在输出中格式化的列。None 表示 __getitem__ 返回所有列（默认）。
output_all_columns (bool, 默认为 False) — 在输出中也保留未格式化的列（作为 Python 对象）。
**format_kwargs (附加关键字参数) — 传递给转换函数的关键字参数，例如 np.array、torch.tensor 或 tensorflow.ragged.constant。

设置 __getitem__ 返回格式（类型和列）。数据格式化是即时应用的。格式 type (例如 “numpy”) 用于在使用 __getitem__ 时格式化批次。

也可以使用自定义转换进行格式化，方法是使用 with_transform()。

与 set_format() 相反，with_format 返回一个新的 Dataset 对象。

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds.format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format(type='tensorflow', columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds.format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'tensorflow'}

with_transform
< source >
( transform: Optional columns: Optional = None output_all_columns: bool = False )

参数

transform (Callable, `可选`) — 用户定义的格式化转换，替换由 set_format() 定义的格式。格式化函数是一个可调用对象，它接受一个批次（作为 `dict`）作为输入并返回一个批次。此函数在 __getitem__ 中返回对象之前立即应用。
columns (List[str], `可选`) — 要在输出中格式化的列。如果指定，则转换的输入批次仅包含这些列。
output_all_columns (bool, 默认为 `False`) — 在输出中也保留未格式化的列（作为 Python 对象）。如果设置为 `True`，则其他未格式化的列将与转换的输出一起保留。

使用此转换设置 __getitem__ 返回格式。当调用 __getitem__ 时，转换会即时应用于批次。

与 set_format() 类似，可以使用 reset_format() 重置此格式。

与 set_transform() 相反，with_transform 返回一个新的 Dataset 对象。

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example["text"], padding=True, truncation=True, return_tensors='pt') >>> ds = ds.with_transform(encode) >>> ds[0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 18027, 16310, 16001, 1103, 9321, 178, 11604, 7235, 6617, 1742, 2165, 2820, 1206, 6588, 22572, 12937, 1811, 2153, 1105, 1147, 12890, 19587, 6463, 1105, 15026, 1482, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}

__getitem__
< source >
( key )

可用于索引列（通过字符串名称）或行（通过整数索引或索引迭代器或布尔值）。

cleanup_cache_files
< source >
( ) → int

返回值

int

移除的文件数量。

清理数据集缓存目录中的所有缓存文件，但如果存在当前正在使用的缓存文件则除外。

运行此命令时请注意，没有其他进程正在使用其他缓存文件。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.cleanup_cache_files() 10

map
< source >
( function: Optional = None with_indices: bool = False with_rank: bool = False input_columns: Union = None batched: bool = False batch_size: Optional = 1000 drop_last_batch: bool = False remove_columns: Union = None keep_in_memory: bool = False load_from_cache_file: Optional = None cache_file_name: Optional = None writer_batch_size: Optional = 1000 features: Optional = None disable_nullable: bool = False fn_kwargs: Optional = None num_proc: Optional = None suffix_template: str = '_{rank:05d}_of_{num_proc:05d}' new_fingerprint: Optional = None desc: Optional = None )

参数

function (Callable) — 具有以下签名之一的函数：

function(example: Dict[str, Any]) -> Dict[str, Any] 如果 batched=False 且 with_indices=False 且 with_rank=False

function(example: Dict[str, Any], *extra_args) -> Dict[str, Any] 如果 batched=False 且 with_indices=True 和/或 with_rank=True (每个参数一个额外参数)

function(batch: Dict[str, List]) -> Dict[str, List] 如果 batched=True 且 with_indices=False 且 with_rank=False

function(batch: Dict[str, List], *extra_args) -> Dict[str, List] 如果 batched=True 且 with_indices=True 和/或 with_rank=True (每个参数一个额外参数)

对于高级用法，该函数还可以返回 pyarrow.Table。此外，如果您的函数不返回任何内容 (`None`)，则 map 将运行您的函数并返回未更改的数据集。如果未提供函数，则默认为恒等函数：`lambda x: x`。
with_indices (bool, 默认为 `False`) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 `def function(example, idx[, rank]): ...`。
with_rank (bool, 默认为 `False`) — 向 function 提供进程排名。请注意，在这种情况下，function 的签名应为 `def function(example[, idx], rank): ...`。
input_columns (Optional[Union[str, List[str]]], 默认为 `None`) — 要作为位置参数传递到 function 中的列。如果为 `None`，则将映射到所有格式化列的 `dict` 作为单个参数传递。
batched (bool, 默认为 `False`) — 向 function 提供示例批次。
batch_size (int, 可选, 默认为 `1000`) — 如果 `batched=True`，则提供给 function 的每个批次的示例数。如果 `batch_size <= 0` 或 `batch_size == None`，则将完整数据集作为单个批次提供给 `function`。
drop_last_batch (bool, 默认为 `False`) — 是否应丢弃小于 batch_size 的最后一个批次，而不是由函数处理。
remove_columns (Optional[Union[str, List[str]]], 默认为 `None`) — 在执行映射时删除选定的列。列将在使用 function 的输出更新示例之前删除，即，如果 function 正在添加名称在 `remove_columns` 中的列，则这些列将被保留。
keep_in_memory (bool, defaults to False) — 将数据集保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], defaults to True if caching is enabled) — 如果可以找到存储来自 function 的当前计算的缓存文件，则使用它而不是重新计算。
cache_file_name (str, optional, defaults to None) — 提供缓存文件的路径名称。它用于存储计算结果，而不是自动生成的缓存文件名。
writer_batch_size (int, defaults to 1000) — 缓存文件写入器的每次写入操作的行数。此值是在处理过程中的内存使用量和处理速度之间取得良好平衡。较高的值使处理执行更少的查找，较低的值在运行 map 时消耗更少的临时内存。
features (Optional[datasets.Features], defaults to None) — 使用特定的 Features 来存储缓存文件，而不是自动生成的文件。
disable_nullable (bool, defaults to False) — 不允许表中的空值。
fn_kwargs (Dict, optional, defaults to None) — 要传递给 function 的关键字参数。
num_proc (int, optional, defaults to None) — 生成缓存时的最大进程数。已缓存的分片会按顺序加载。
suffix_template (str) — 如果指定了 cache_file_name，则此后缀将添加到每个基本名称的末尾。默认为 "_{rank:05d}_of_{num_proc:05d}"。例如，如果 cache_file_name 是 “processed.arrow”，那么对于 rank=1 和 num_proc=4，对于默认后缀，生成的文件将是 "processed_00001_of_00004.arrow"。
new_fingerprint (str, optional, defaults to None) — 转换后数据集的新指纹。如果为 None，则使用先前指纹的哈希和转换参数计算新指纹。
desc (str, optional, defaults to None) — 有意义的描述，与映射示例时的进度条一起显示。

将函数应用于表中的所有示例（单独或批量），并更新表。如果您的函数返回的列已存在，则会覆盖它。

您可以使用 batched 参数指定函数是否应分批处理

如果 batched 为 False，则该函数接受 1 个示例作为输入，并且应返回 1 个示例。示例是一个字典，例如 {"text": "Hello there !"}。

如果 batched 为 True 且 batch_size 为 1，则该函数接受 1 个示例的批次作为输入，并且可以返回包含 1 个或多个示例的批次。批次是一个字典，例如，1 个示例的批次是 {"text": ["Hello there !"]}。

如果 batched 为 True 且 batch_size 为 n > 1，则该函数接受 n 个示例的批次作为输入，并且可以返回包含 n 个示例或任意数量示例的批次。请注意，最后一个批次可能少于 n 个示例。批次是一个字典，例如，n 个示例的批次是 {"text": ["Hello there !"] * n}。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds[0:3]["text"] ['Review: compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .', 'Review: the soundtrack alone is worth the price of admission .', 'Review: rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4)

filter
< source >
( function: Optional = None with_indices: bool = False with_rank: bool = False input_columns: Union = None batched: bool = False batch_size: Optional = 1000 keep_in_memory: bool = False load_from_cache_file: Optional = None cache_file_name: Optional = None writer_batch_size: Optional = 1000 fn_kwargs: Optional = None num_proc: Optional = None suffix_template: str = '_{rank:05d}_of_{num_proc:05d}' new_fingerprint: Optional = None desc: Optional = None )

参数

function (Callable) — 具有以下签名之一的可调用对象：

function(example: Dict[str, Any]) -> bool 如果 batched=False 且 with_indices=False 且 with_rank=False

function(example: Dict[str, Any], *extra_args) -> bool 如果 batched=False 且 with_indices=True 和/或 with_rank=True（每个额外的参数一个）

function(batch: Dict[str, List]) -> List[bool] 如果 batched=True 且 with_indices=False 且 with_rank=False

function(batch: Dict[str, List], *extra_args) -> List[bool] 如果 batched=True 且 with_indices=True 和/或 with_rank=True（每个额外的参数一个）

如果未提供函数，则默认为始终为 True 的函数：lambda x: True。
with_indices (bool, defaults to False) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 def function(example, idx[, rank]): ...。
with_rank (bool, defaults to False) — 向 function 提供进程排名。请注意，在这种情况下，function 的签名应为 def function(example[, idx], rank): ...。
input_columns (str or List[str], optional) — 要作为位置参数传递到 function 中的列。如果为 None，则将映射到所有格式化列的 dict 作为单个参数传递。
batched (bool, defaults to False) — 向 function 提供一批示例。
batch_size (int, optional, defaults to 1000) — 如果 batched = True，则提供给 function 的每个批次的示例数。如果 batched = False，则每个批次传递一个示例给 function。如果 batch_size <= 0 或 batch_size == None，则将完整数据集作为单个批次提供给 function。
keep_in_memory (bool, defaults to False) — 将数据集保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], defaults to True if caching is enabled) — 如果可以找到存储来自 function 的当前计算的缓存文件，则使用它而不是重新计算。
cache_file_name (str, optional) — 提供缓存文件的路径名称。它用于存储计算结果，而不是自动生成的缓存文件名。
writer_batch_size (int, defaults to 1000) — 缓存文件写入器的每次写入操作的行数。此值是在处理过程中的内存使用量和处理速度之间取得良好平衡。较高的值使处理执行更少的查找，较低的值在运行 map 时消耗更少的临时内存。
fn_kwargs (dict, optional) — 要传递给 function 的关键字参数。
num_proc (int, optional) — 用于多处理的进程数。默认情况下，它不使用多处理。
suffix_template (str) — 如果指定了 cache_file_name，则此后缀将添加到每个基本名称的末尾。例如，如果 cache_file_name 是 "processed.arrow"，那么对于 rank = 1 和 num_proc = 4，对于默认后缀（默认 _{rank:05d}_of_{num_proc:05d}），生成的文件将是 "processed_00001_of_00004.arrow"。
new_fingerprint (str, optional) — 转换后的数据集的新指纹。如果为 None，则新指纹通过使用先前指纹的哈希和转换参数计算得出。
desc (str, optional, defaults to None) — 在过滤示例时，与进度条一起显示的有意义的描述。

对表格中的所有元素批量应用过滤器函数，并更新表格，使数据集仅包含符合过滤器函数的示例。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.filter(lambda x: x["label"] == 1) Dataset({ features: ['text', 'label'], num_rows: 533 })

select
< source >
( indices: Iterable keep_in_memory: bool = False indices_cache_file_name: Optional = None writer_batch_size: Optional = 1000 new_fingerprint: Optional = None )

参数

indices (range, list, iterable, ndarray or Series) — 用于索引的整数索引的范围、列表或一维数组。如果索引对应于连续范围，则 Arrow 表格将被简单地切片。但是，传递非连续索引列表会创建索引映射，效率较低，但仍然比重新创建由请求的行组成的 Arrow 表格更快。
keep_in_memory (bool, defaults to False) — 将索引映射保存在内存中，而不是写入缓存文件。
indices_cache_file_name (str, optional, defaults to None) — 提供缓存文件的路径名称。它用于存储索引映射，而不是自动生成的缓存文件名。
writer_batch_size (int, defaults to 1000) — 缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间取得良好平衡。较高的值使处理执行较少的查找，较低的值在运行 map 时消耗较少的临时内存。
new_fingerprint (str, optional, defaults to None) — 转换后的数据集的新指纹。如果为 None，则新指纹通过使用先前指纹的哈希和转换参数计算得出。

创建一个新数据集，其中的行按照索引列表/数组选择。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds.select(range(4)) Dataset({ features: ['text', 'label'], num_rows: 4 })

sort
< source >
( column_names: Union reverse: Union = False null_placement: str = 'at_end' keep_in_memory: bool = False load_from_cache_file: Optional = None indices_cache_file_name: Optional = None writer_batch_size: Optional = 1000 new_fingerprint: Optional = None )

参数

column_names (Union[str, Sequence[str]]) — 要排序的列名。
reverse (Union[bool, Sequence[bool]], defaults to False) — 如果为 True，则按降序而不是升序排序。如果提供单个布尔值，则该值将应用于所有列名的排序。否则，必须提供与 column_names 长度和顺序相同的布尔值列表。
null_placement (str, defaults to at_end) — 如果为 at_start 或 first，则将 None 值放在开头；如果为 at_end 或 last，则将 None 值放在末尾。

在 1.14.2 版本中添加

keep_in_memory (bool, defaults to False) — 将排序后的索引保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], defaults to True if caching is enabled) — 如果可以找到存储排序后索引的缓存文件，则使用它，而不是重新计算。
indices_cache_file_name (str, optional, defaults to None) — 提供缓存文件的路径名称。它用于存储排序后的索引，而不是自动生成的缓存文件名。
writer_batch_size (int, defaults to 1000) — 缓存文件写入器的每次写入操作的行数。较高的值会生成较小的缓存文件，较低的值会消耗较少的临时内存。
new_fingerprint (str, optional, defaults to None) — 转换后的数据集的新指纹。如果为 None，则新指纹通过使用先前指纹的哈希和转换参数计算得出

创建一个新数据集，该数据集根据单个或多个列排序。

示例

>>> from datasets import load_dataset >>> ds = load_dataset('rotten_tomatoes', split='validation') >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

shuffle
< source >
( seed: Optional = None generator: Optional = None keep_in_memory: bool = False load_from_cache_file: Optional = None indices_cache_file_name: Optional = None writer_batch_size: Optional = 1000 new_fingerprint: Optional = None )

参数

seed (int, optional) — 用于初始化默认 BitGenerator 的种子，如果 generator=None。如果为 None，则会从操作系统中提取新的、不可预测的熵。如果传递 int 或 array_like[ints]，则会将其传递给 SeedSequence 以导出初始 BitGenerator 状态。
generator (numpy.random.Generator, optional) — Numpy 随机 Generator，用于计算数据集行的排列。如果 generator=None（默认），则使用 np.random.default_rng（NumPy 的默认 BitGenerator (PCG64)）。
keep_in_memory (bool, default False) — 将打乱顺序的索引保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], defaults to True if caching is enabled) — 如果可以找到存储打乱顺序的索引的缓存文件，则使用它，而不是重新计算。
indices_cache_file_name (str, optional) — 提供缓存文件的路径名称。它用于存储打乱顺序的索引，而不是自动生成的缓存文件名。
writer_batch_size (int, defaults to 1000) — 缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间取得良好平衡。较高的值使处理执行较少的查找，较低的值在运行 map 时消耗较少的临时内存。
new_fingerprint (str, 可选, 默认为 None) — 转换后数据集的新指纹。如果为 None，则新指纹将使用先前的指纹和转换参数的哈希值计算得出。

创建一个新 Dataset，其中的行已被打乱顺序。

当前，打乱顺序使用 numpy 随机生成器。您可以提供要使用的 NumPy BitGenerator，或提供一个种子来初始化 NumPy 的默认随机生成器 (PCG64)。

打乱顺序会获取索引列表 [0:len(my_dataset)] 并对其进行洗牌以创建索引映射。但是，一旦您的 Dataset 具有索引映射，速度可能会降低 10 倍。这是因为需要额外的步骤来使用索引映射获取要读取的行索引，最重要的是，您不再读取连续的数据块。要恢复速度，您需要使用 Dataset.flatten_indices() 再次将整个数据集重写到磁盘上，这将删除索引映射。

但这可能需要很长时间，具体取决于数据集的大小。

my_dataset[0] # fast my_dataset = my_dataset.shuffle(seed=42) my_dataset[0] # up to 10x slower my_dataset = my_dataset.flatten_indices() # rewrite the shuffled dataset on disk as contiguous chunks of data my_dataset[0] # fast again

在这种情况下，我们建议切换到 IterableDataset 并利用其快速的近似洗牌方法 IterableDataset.shuffle()。

它仅打乱分片顺序，并为您的数据集添加一个洗牌缓冲区，从而保持数据集的最佳速度。

my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=128) for example in enumerate(my_iterable_dataset): # fast pass shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100) for example in enumerate(shuffled_iterable_dataset): # as fast as before pass

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds['label'][:10] [1, 0, 1, 1, 0, 0, 0, 0, 0, 0]

跳过
 < 源代码 >
( n: int )

参数

n (int) — 要跳过的元素数量。

创建一个新的 Dataset，它跳过前 n 个元素。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train") >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}]

选取
 < 源代码 >
( n: int )

参数

n (int) — 要选取的元素数量。

创建一个新的 Dataset，其中仅包含前 n 个元素。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train") >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}]

train_test_split
< 源代码 >
( test_size: Union = None train_size: Union = None shuffle: bool = True stratify_by_column: Optional = None seed: Optional = None generator: Optional = None keep_in_memory: bool = False load_from_cache_file: Optional = None train_indices_cache_file_name: Optional = None test_indices_cache_file_name: Optional = None writer_batch_size: Optional = 1000 train_new_fingerprint: Optional = None test_new_fingerprint: Optional = None )

参数

test_size (numpy.random.Generator, 可选) — 测试集拆分的大小。如果为 float，则应介于 0.0 和 1.0 之间，并表示要包含在测试集拆分中的数据集比例。如果为 int，则表示测试样本的绝对数量。如果为 None，则该值设置为训练集大小的补集。如果 train_size 也为 None，则它将被设置为 0.25。
train_size (numpy.random.Generator, 可选) — 训练集拆分的大小。如果为 float，则应介于 0.0 和 1.0 之间，并表示要包含在训练集拆分中的数据集比例。如果为 int，则表示训练样本的绝对数量。如果为 None，则该值将自动设置为测试集大小的补集。
shuffle (bool, 可选, 默认为 True) — 在拆分之前是否打乱数据。
stratify_by_column (str, 可选, 默认为 None) — 用于执行分层数据拆分的标签列名。
seed (int, 可选) — 用于初始化默认 BitGenerator 的种子，如果 generator=None。如果为 None，则将从操作系统中提取新鲜的、不可预测的熵。如果传递 int 或 array_like[ints]，则它将传递给 SeedSequence 以派生初始 BitGenerator 状态。
generator (numpy.random.Generator, 可选) — 用于计算数据集行排列的 Numpy 随机生成器。如果 generator=None (默认)，则使用 np.random.default_rng (NumPy 的默认 BitGenerator (PCG64))。
keep_in_memory (bool, 默认为 False) — 将拆分索引保留在内存中，而不是将其写入缓存文件。
load_from_cache_file (Optional[bool], 如果启用缓存，则默认为 True) — 如果可以识别存储拆分索引的缓存文件，则使用它而不是重新计算。
train_cache_file_name (str, 可选) — 提供缓存文件的路径名称。它用于存储训练集拆分索引，而不是自动生成的缓存文件名。
test_cache_file_name (str, 可选) — 提供缓存文件的路径名称。它用于存储测试集拆分索引，而不是自动生成的缓存文件名。
writer_batch_size (int, 默认为 1000) — 用于缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间取得良好折衷的值。较高的值使处理执行的查找次数更少，较低的值在运行 map 时消耗的临时内存更少。
train_new_fingerprint (str, 可选, 默认为 None) — 转换后训练集的新指纹。如果为 None，则新指纹将使用先前的指纹和转换参数的哈希值计算得出。
test_new_fingerprint (str, 可选, 默认为 None) — 转换后测试集的新指纹。如果为 None，则新指纹将使用先前的指纹和转换参数的哈希值计算得出。

返回一个字典 (datasets.DatasetDict)，其中包含两个随机的训练集和测试集子集（train 和 test Dataset 拆分）。拆分是根据 test_size、train_size 和 shuffle 从数据集创建的。

此方法类似于 scikit-learn 的 train_test_split。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds = ds.train_test_split(test_size=0.2, shuffle=True) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 852 }) test: Dataset({ features: ['text', 'label'], num_rows: 214 }) }) # set a seed >>> ds = ds.train_test_split(test_size=0.2, seed=42) # stratified split >>> ds = load_dataset("imdb",split="train") Dataset({ features: ['text', 'label'], num_rows: 25000 }) >>> ds = ds.train_test_split(test_size=0.2, stratify_by_column="label") DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 20000 }) test: Dataset({ features: ['text', 'label'], num_rows: 5000 }) })

分片
 < 源代码 >
( num_shards: int index: int contiguous: bool = False keep_in_memory: bool = False indices_cache_file_name: Optional = None writer_batch_size: Optional = 1000 )

参数

num_shards (int) — 要将数据集拆分成的分片数量。
index (int) — 要选择和返回的分片索引。 contiguous — (bool, 默认为 False): 是否为分片选择连续的索引块。
keep_in_memory (bool, 默认为 False) — 将数据集保留在内存中，而不是将其写入缓存文件。
indices_cache_file_name (str, 可选) — 提供缓存文件的路径名称。它用于存储每个分片的索引，而不是自动生成的缓存文件名。
writer_batch_size (int, 默认为 1000) — 用于缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间取得良好折衷的值。较高的值使处理执行的查找次数更少，较低的值在运行 map 时消耗的临时内存更少。

从数据集拆分为 num_shards 块中返回第 index 个分片。

此分片是确定性的。dset.shard(n, i) 将包含索引 mod n = i 的 dset 的所有元素。

dset.shard(n, i, contiguous=True) 将数据集拆分为连续的块，以便在处理后可以轻松地将它们重新连接在一起。如果 n % i == l，则前 l 个分片的长度为 (n // i) + 1，其余分片的长度为 (n // i)。 datasets.concatenate([dset.shard(n, i, contiguous=True) for i in range(n)]) 将返回与原始数据集顺序相同的数据集。

请务必在任何随机化运算符（例如 shuffle）之前进行分片。最好在数据集管道的早期使用分片运算符。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="validation") >>> ds Dataset({ features: ['text', 'label'], num_rows: 1066 }) >>> ds.shard(num_shards=2, index=0) Dataset({ features: ['text', 'label'], num_rows: 533 })

to_tf_dataset
< source >
( batch_size: Optional = None columns: Union = None shuffle: bool = False collate_fn: Optional = None drop_remainder: bool = False collate_fn_args: Optional = None label_cols: Union = None prefetch: bool = True num_workers: int = 0 num_test_batches: int = 20 )

参数

batch_size (int, 可选) — 从数据集中加载的批次大小。默认为 None，这意味着数据集不会被批处理，但返回的数据集稍后可以使用 tf_dataset.batch(batch_size) 进行批处理。
columns (List[str] 或 str, 可选) — 要在 tf.data.Dataset 中加载的数据集列。可以使用由 collate_fn 创建且在原始数据集中不存在的列名。
shuffle(bool, 默认为 False) — 加载时随机打乱数据集顺序。建议训练时使用 True，验证/评估时使用 False。
drop_remainder(bool, 默认为 False) — 加载时丢弃最后一个不完整的批次。确保数据集产生的所有批次在批次维度上具有相同的长度。
collate_fn(Callable, 可选) — 一个函数或可调用对象（例如 DataCollator），它将样本列表整理成一个批次。
collate_fn_args (Dict, 可选) — 要传递给 collate_fn 的可选关键字参数字典。
label_cols (List[str] 或 str, 默认为 None) — 要加载为标签的数据集列。请注意，许多模型在内部计算损失，而不是让 Keras 执行此操作，在这种情况下，只要标签在输入 columns 中，在此处传递标签是可选的。
prefetch (bool, 默认为 True) — 是否在单独的线程中运行数据加载器，并维护一个小的批次缓冲区以进行训练。通过允许在后台加载数据，同时模型正在训练，从而提高性能。
num_workers (int, 默认为 0) — 用于加载数据集的工作进程数。仅在 Python 版本 >= 3.8 上受支持。
num_test_batches (int, 默认为 20) — 用于推断数据集的输出签名的批次数。这个数字越高，签名将越准确，但创建数据集所需的时间也越长。

从底层 Dataset 创建一个 tf.data.Dataset。此 tf.data.Dataset 将从 Dataset 加载和整理批次，并且适合传递给 model.fit() 或 model.predict() 等方法。数据集将为输入和标签生成 dicts，除非 dict 只包含一个键，在这种情况下，将改为生成原始 tf.Tensor。

示例

>>> ds_train = ds["train"].to_tf_dataset( ... columns=['input_ids', 'token_type_ids', 'attention_mask', 'label'], ... shuffle=True, ... batch_size=16, ... collate_fn=data_collator, ... )

push_to_hub
< source >
( repo_id: str config_name: str = 'default' set_default: Optional = None split: Optional = None data_dir: Optional = None commit_message: Optional = None commit_description: Optional = None private: Optional = False token: Optional = None revision: Optional = None create_pr: Optional = False max_shard_size: Union = None num_shards: Optional = None embed_external_files: bool = True )

参数

repo_id (str) — 要推送到的仓库 ID，格式如下：<user>/<dataset_name> 或 <org>/<dataset_name>。也接受 <dataset_name>，这将默认为已登录用户的命名空间。
config_name (str, 默认为 “default”) — 数据集的配置名称（或子集）。默认为 “default”。
set_default (bool, 可选) — 是否将此配置设置为默认配置。否则，默认配置是名为 “default” 的配置。
split (str, 可选) — 将分配给该数据集的划分名称。默认为 self.split。
data_dir (str, 可选) — 将包含上传数据文件的目录名称。如果与 “default” 不同，则默认为 config_name，否则为 “data”。

在 2.17.0 中添加

commit_message (str, 可选) — 推送时提交的消息。默认为 "Upload dataset"。
commit_description (str, 可选) — 将被创建的提交的描述。此外，如果创建了 PR（create_pr 为 True），则也是 PR 的描述。

在 2.16.0 中添加

private (bool, 可选, 默认为 False) — 数据集仓库是否应设置为私有。仅影响仓库创建：已存在的仓库不受此参数影响。
token (str, 可选) — Hugging Face Hub 的可选身份验证令牌。如果未传递令牌，则默认为使用 huggingface-cli login 登录时本地保存的令牌。如果未传递令牌且用户未登录，则会引发错误。
revision (str, 可选) — 将上传的文件推送到的分支。默认为 "main" 分支。

在 2.15.0 中添加

create_pr (bool, 可选, 默认为 False) — 是否使用上传的文件创建 PR 或直接提交。

在 2.15.0 中添加

max_shard_size (int 或 str, 可选, 默认为 "500MB") — 上传到 hub 的数据集分片的最大大小。如果表示为字符串，则需要是数字后跟单位（例如 "5MB"）。
num_shards (int, 可选) — 要写入的分片数量。默认情况下，分片数量取决于 max_shard_size。

在 2.8.0 版本中添加

embed_external_files (bool, 默认为 True) — 是否将文件字节嵌入到分片中。特别是，这将在推送之前对以下类型的字段执行以下操作：

Audio 和 Image: 删除本地路径信息并将文件内容嵌入到 Parquet 文件中。

将数据集作为 Parquet 数据集推送到 hub。数据集使用 HTTP 请求推送，无需安装 git 或 git-lfs。

默认情况下，生成的 Parquet 文件是自包含的。如果您的数据集包含 Image 或 Audio 数据，则 Parquet 文件将存储您的图像或音频文件的字节。您可以通过将 embed_external_files 设置为 False 来禁用此功能。

示例

>>> dataset.push_to_hub("<organization>/<dataset_id>") >>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True) >>> dataset.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB") >>> dataset.push_to_hub("<organization>/<dataset_id>", num_shards=1024)

如果您的数据集有多个拆分（例如，train/validation/test）

>>> train_dataset.push_to_hub("<organization>/<dataset_id>", split="train") >>> val_dataset.push_to_hub("<organization>/<dataset_id>", split="validation") >>> # later >>> dataset = load_dataset("<organization>/<dataset_id>") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"]

如果您想向数据集添加新的配置（或子集）（例如，如果数据集有多个任务/版本/语言）

>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en") >>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr") >>> # later >>> english_dataset = load_dataset("<organization>/<dataset_id>", "en") >>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")

save_to_disk
< source >
( dataset_path: Union max_shard_size: Union = None num_shards: Optional = None num_proc: Optional = None storage_options: Optional = None )

参数

dataset_path (path-like) — 数据集目录的路径（例如 dataset/train）或远程 URI（例如 s3://my-bucket/dataset/train），数据集将保存到此处。
max_shard_size (int 或 str, 可选, 默认为 "500MB") — 上传到 hub 的数据集分片的最大大小。如果表示为字符串，则需要是数字后跟单位（例如 "50MB"）。
num_shards (int, 可选) — 要写入的分片数量。默认情况下，分片的数量取决于 max_shard_size 和 num_proc。

在 2.8.0 版本中添加

num_proc (int, 可选) — 本地下载和生成数据集时使用的进程数。默认情况下禁用多处理。

在 2.8.0 版本中添加

storage_options (dict, 可选) — 要传递给文件系统后端的键/值对（如果有）。

在 2.8.0 版本中添加

将数据集保存到数据集目录中，或使用任何 fsspec.spec.AbstractFileSystem 实现的文件系统。

对于 Image 和 Audio 数据

所有 Image() 和 Audio() 数据都存储在 arrow 文件中。如果要存储路径或 URL，请使用 Value(“string”) 类型。

示例

>>> ds.save_to_disk("path/to/dataset/directory") >>> ds.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> ds.save_to_disk("path/to/dataset/directory", num_shards=1024)

load_from_disk
< source >
( dataset_path: Union keep_in_memory: Optional = None storage_options: Optional = None ) → Dataset 或 DatasetDict

参数

dataset_path (path-like) — 数据集目录的路径（例如 "dataset/train"）或远程 URI（例如 "s3//my-bucket/dataset/train"），数据集将从此处加载。
keep_in_memory (bool, 默认为 None) — 是否将数据集复制到内存中。如果为 None，则除非通过将 datasets.config.IN_MEMORY_MAX_SIZE 设置为非零值显式启用，否则数据集不会复制到内存中。有关更多详细信息，请参见提高性能部分。
storage_options (dict, 可选) — 要传递给文件系统后端的键/值对（如果有）。

在 2.8.0 版本中添加

返回值

Dataset 或 DatasetDict

如果 dataset_path 是数据集目录的路径，则返回请求的数据集。

如果 dataset_path 是数据集字典目录的路径，则返回包含每个拆分的 datasets.DatasetDict。

从数据集目录或使用任何 fsspec.spec.AbstractFileSystem 实现的文件系统加载先前使用 save_to_disk 保存的数据集。

示例

>>> ds = load_from_disk("path/to/dataset/directory")

flatten_indices
< source >
( keep_in_memory: bool = False cache_file_name: Optional = None writer_batch_size: Optional = 1000 features: Optional = None disable_nullable: bool = False num_proc: Optional = None new_fingerprint: Optional = None )

参数

keep_in_memory (bool, 默认为 False) — 将数据集保存在内存中，而不是写入缓存文件。
cache_file_name (str, 可选, 默认为 None) — 提供缓存文件的路径名称。它用于存储计算结果，而不是自动生成的缓存文件名。
writer_batch_size (int, 默认为 1000) — 用于缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间取得良好折衷的值。较高的值使处理执行的查找次数更少，较低的值在运行 map 时消耗的临时内存更少。
features (Optional[datasets.Features], 默认为 None) — 使用特定的 Features 来存储缓存文件，而不是自动生成的文件。
disable_nullable (bool, 默认为 False) — 允许表中使用 null 值。
num_proc (int, 可选, 默认为 None) — 生成缓存时使用的最大进程数。已经缓存的分片将按顺序加载
new_fingerprint (str, 可选, 默认为 None) — 转换后数据集的新指纹。如果为 None，则新指纹使用先前指纹的哈希值和转换参数计算得出

通过展平索引映射创建并缓存新的 Dataset。

to_csv
< source >
( path_or_buf: Union batch_size: Optional = None num_proc: Optional = None storage_options: Optional = None **to_csv_kwargs ) → int

参数

path_or_buf (PathLike 或 FileOrBuffer) — 文件路径（例如 file.csv）、远程 URI（例如 hf://datasets/username/my_dataset_name/data.csv）或 BinaryIO，数据集将以指定的格式保存到此处。
batch_size (int, optional) — 内存中一次加载和写入的批次大小。默认为 datasets.config.DEFAULT_MAX_BATCH_SIZE。
num_proc (int, optional) — 用于多进程处理的进程数。默认情况下不使用多进程。在这种情况下，batch_size 默认值为 datasets.config.DEFAULT_MAX_BATCH_SIZE，但如果您有足够的计算能力，可以随意将其设置为默认值的 5 倍或 10 倍。
storage_options (dict, optional) — 传递给文件系统后端的键值对（如果有）。

在 2.19.0 版本中添加

**to_csv_kwargs (附加关键字参数) — 传递给 pandas 的 pandas.DataFrame.to_csv 的参数。

在 2.10.0 版本中更改

现在，如果未指定 index，则默认为 False。

如果您想写入索引，请传递 index=True，并通过传递 index_label 为索引列设置名称。

返回值

int

写入的字符数或字节数。

将数据集导出为 csv 文件

示例

>>> ds.to_csv("path/to/dataset/directory")

to_pandas
< source >
( batch_size: Optional = None batched: bool = False )

参数

batched (bool) — 设置为 True 以返回一个生成器，该生成器以 batch_size 行的批次形式生成数据集。默认为 False（一次返回整个数据集）。
batch_size (int, optional) — 如果 batched 为 True，则为批次的大小（行数）。默认为 datasets.config.DEFAULT_MAX_BATCH_SIZE。

将数据集作为 pandas.DataFrame 返回。也可以为大型数据集返回生成器。

示例

>>> ds.to_pandas()

to_dict
< source >
( batch_size: Optional = None )

参数

batch_size (int, optional) — 如果 batched 为 True，则为批次的大小（行数）。默认为 datasets.config.DEFAULT_MAX_BATCH_SIZE。

将数据集作为 Python 字典返回。也可以为大型数据集返回生成器。

示例

>>> ds.to_dict()

to_json
< source >
( path_or_buf: Union batch_size: Optional = None num_proc: Optional = None storage_options: Optional = None **to_json_kwargs ) → int

参数

path_or_buf (PathLike 或 FileOrBuffer) — 文件路径 (例如 file.json)、远程 URI (例如 hf://datasets/username/my_dataset_name/data.json) 或 BinaryIO，数据集将以指定的格式保存到其中。
batch_size (int, optional) — 内存中一次加载和写入的批次大小。默认为 datasets.config.DEFAULT_MAX_BATCH_SIZE。
num_proc (int, optional) — 用于多进程处理的进程数。默认情况下，不使用多进程。在这种情况下，batch_size 默认值为 datasets.config.DEFAULT_MAX_BATCH_SIZE，但如果您有足够的计算能力，可以随意将其设置为默认值的 5 倍或 10 倍。
storage_options (dict, optional) — 传递给文件系统后端的键值对（如果有）。

在 2.19.0 版本中添加

**to_json_kwargs (附加关键字参数) — 传递给 pandas 的 pandas.DataFrame.to_json 的参数。默认参数为 lines=True 和 `orient=“records”。

在 2.11.0 版本中更改

如果 orient 为 "split" 或 "table"，则参数 index 默认为 False。

如果您想写入索引，请传递 index=True。

返回值

int

写入的字符数或字节数。

将数据集导出为 JSON Lines 或 JSON。

默认输出格式为 JSON Lines。要导出为 JSON，请传递 lines=False 参数和所需的 orient。

示例

>>> ds.to_json("path/to/dataset/directory/filename.jsonl")

to_parquet
< source >
( path_or_buf: Union batch_size: Optional = None storage_options: Optional = None **parquet_writer_kwargs ) → int

参数

path_or_buf (PathLike 或 FileOrBuffer) — 文件路径 (例如 file.parquet)、远程 URI (例如 hf://datasets/username/my_dataset_name/data.parquet) 或 BinaryIO，数据集将以指定的格式保存到其中。
batch_size (int, optional) — 内存中一次加载和写入的批次大小。默认为 datasets.config.DEFAULT_MAX_BATCH_SIZE。
storage_options (dict, optional) — 传递给文件系统后端的键值对（如果有）。

在 2.19.0 版本中添加

**parquet_writer_kwargs (附加关键字参数) — 传递给 PyArrow 的 pyarrow.parquet.ParquetWriter 的参数。

返回值

int

写入的字符数或字节数。

将数据集导出为 parquet 文件

示例

>>> ds.to_parquet("path/to/dataset/directory")

to_sql
< source >
( name: str con: Union batch_size: Optional = None **sql_writer_kwargs ) → int

参数

name (str) — SQL 表的名称。
con (str 或 sqlite3.Connection 或 sqlalchemy.engine.Connection 或 sqlalchemy.engine.Connection) — 用于写入数据库的 URI 字符串或 SQLite3/SQLAlchemy 连接对象。
batch_size (int, optional) — 内存中一次加载和写入的批次大小。默认为 datasets.config.DEFAULT_MAX_BATCH_SIZE。
**sql_writer_kwargs (附加关键字参数) — 传递给 pandas’s pandas.DataFrame.to_sql 的参数。

在 2.11.0 版本中变更

现在，如果未指定 index，则默认为 False。

如果您想写入索引，请传递 index=True，并通过传递 index_label 为索引列设置名称。

返回值

int

写入的记录数。

将数据集导出到 SQL 数据库。

示例

>>> # con provided as a connection URI string >>> ds.to_sql("data", "sqlite:///my_own_db.sql") >>> # con provided as a sqlite3 connection object >>> import sqlite3 >>> con = sqlite3.connect("my_own_db.sql") >>> with con: ... ds.to_sql("data", con)

to_iterable_dataset
< source >
( num_shards: Optional = 1 )

参数

num_shards (int, 默认为 1) — 实例化可迭代数据集时要定义的 shards 数量。这对于大型数据集尤其有用，以便能够正确地进行 shuffle，并且能够在使用 PyTorch DataLoader 时或在分布式设置中实现快速并行加载。Shards 使用 datasets.Dataset.shard() 定义：它只是对数据进行切片，而不在磁盘上写入任何内容。

从 map-style datasets.Dataset 获取 datasets.IterableDataset。这等效于使用 datasets.load_dataset() 在流模式下加载数据集，但速度更快，因为数据是从本地文件流式传输的。

与 map-style 数据集相反，可迭代数据集是惰性的，只能迭代（例如，使用 for 循环）。由于它们在训练循环中按顺序读取，因此可迭代数据集比 map-style 数据集快得多。应用于可迭代数据集的所有转换（如过滤或处理）都在您开始迭代数据集时即时完成。

尽管如此，仍然可以使用 datasets.IterableDataset.shuffle() 对可迭代数据集进行 shuffle。这是一种快速的近似 shuffle，如果您有多个 shards 并且指定了足够大的缓冲区大小，则效果最佳。

为了获得最佳速度性能，请确保您的数据集没有索引映射。如果是这种情况，则数据不是连续读取的，有时可能会很慢。您可以使用 ds = ds.flatten_indices() 将您的数据集写入连续的数据块，并在切换到可迭代数据集之前获得最佳速度。

示例

基本用法

>>> ids = ds.to_iterable_dataset() >>> for example in ids: ... pass

使用惰性过滤和处理

>>> ids = ds.to_iterable_dataset() >>> ids = ids.filter(filter_fn).map(process_fn) # will filter and process on-the-fly when you start iterating over the iterable dataset >>> for example in ids: ... pass

使用 sharding 以实现高效的 shuffle

>>> ids = ds.to_iterable_dataset(num_shards=64) # the dataset is split into 64 shards to be iterated over >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer for fast approximate shuffling when you start iterating >>> for example in ids: ... pass

使用 PyTorch DataLoader

>>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.filter(filter_fn).map(process_fn) >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards to each worker to load, filter and process when you start iterating >>> for example in ids: ... pass

使用 PyTorch DataLoader 和 shuffle

>>> import torch >>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating >>> for example in ids: ... pass

在分布式设置（如 PyTorch DDP）中使用 PyTorch DataLoader 和 shuffle

>>> from datasets.distributed import split_dataset_by_node >>> ids = ds.to_iterable_dataset(num_shards=512) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> ids = split_dataset_by_node(ds, world_size=8, rank=0) # will keep only 512 / 8 = 64 shards from the shuffled lists of shards when you start iterating >>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4) # will assign 64 / 4 = 16 shards from this node's list of shards to each worker when you start iterating >>> for example in ids: ... pass

使用 shuffle 和多个 epochs

>>> ids = ds.to_iterable_dataset(num_shards=64) >>> ids = ids.shuffle(buffer_size=10_000, seed=42) # will shuffle the shards order and use a shuffle buffer when you start iterating >>> for epoch in range(n_epochs): ... ids.set_epoch(epoch) # will use effective_seed = seed + epoch to shuffle the shards and for the shuffle buffer when you start iterating ... for example in ids: ... pass
当使用 PyTorch DataLoader 或在分布式设置中时，也可以随意使用 `IterableDataset.set_epoch()`。

add_faiss_index
< source >
( column: str index_name: Optional = None device: Optional = None string_factory: Optional = None metric_type: Optional = None custom_index: Optional = None batch_size: int = 1000 train_size: Optional = None faiss_verbose: bool = False dtype = <class 'numpy.float32'> )

参数

column (str) — 要添加到索引的向量列。
index_name (str, 可选) — 索引的 index_name/标识符。这是用于调用 get_nearest_examples() 或 search() 的 index_name。默认情况下，它对应于 column。
device (Union[int, List[int]], 可选) — 如果是正整数，则这是要使用的 GPU 的索引。如果是负整数，则使用所有 GPU。如果传入正整数列表，则仅在这些 GPU 上运行。默认情况下，它使用 CPU。
string_factory (str, 可选) — 这会传递给 Faiss 的索引工厂以创建索引。默认索引类为 IndexFlat。
metric_type (int, 可选) — 指标类型。例如：faiss.METRIC_INNER_PRODUCT 或 faiss.METRIC_L2。
custom_index (faiss.Index, 可选) — 您已实例化并根据您的需求配置的自定义 Faiss 索引。
batch_size (int) — 将向量添加到 FaissIndex 时要使用的批次大小。默认值为 1000。

在 2.4.0 版本中添加

train_size (int, 可选) — 如果索引需要训练步骤，则指定将使用多少向量来训练索引。
faiss_verbose (bool, 默认为 False) — 启用 Faiss 索引的详细模式。
dtype (data-type) — 被索引的 numpy 数组的 dtype。默认为 np.float32。

添加使用 Faiss 的密集索引以进行快速检索。默认情况下，索引是在指定列的向量上完成的。如果您想在 GPU 上运行它，可以指定 device（device 必须是 GPU 索引）。您可以在这里找到有关 Faiss 的更多信息

关于字符串工厂

示例

>>> ds = datasets.load_dataset('crime_and_punish', split='train') >>> ds_with_embeddings = ds.map(lambda example: {'embeddings': embed(example['line']})) >>> ds_with_embeddings.add_faiss_index(column='embeddings') >>> # query >>> scores, retrieved_examples = ds_with_embeddings.get_nearest_examples('embeddings', embed('my new query'), k=10) >>> # save index >>> ds_with_embeddings.save_faiss_index('embeddings', 'my_index.faiss') >>> ds = datasets.load_dataset('crime_and_punish', split='train') >>> # load index >>> ds.load_faiss_index('embeddings', 'my_index.faiss') >>> # query >>> scores, retrieved_examples = ds.get_nearest_examples('embeddings', embed('my new query'), k=10)

add_faiss_index_from_external_arrays
< source >
( external_arrays: array index_name: str device: Optional = None string_factory: Optional = None metric_type: Optional = None custom_index: Optional = None batch_size: int = 1000 train_size: Optional = None faiss_verbose: bool = False dtype = <class 'numpy.float32'> )

参数

external_arrays (np.array) — 如果您想使用库外部的数组进行索引，您可以设置 external_arrays。它将使用 external_arrays 创建 Faiss 索引，而不是给定 column 中的数组。
index_name (str) — 索引的 index_name/标识符。这是用于调用 get_nearest_examples() 或 search() 的 index_name。
device (Optional Union[int, List[int]], 可选) — 如果是正整数，则这是要使用的 GPU 的索引。如果是负整数，则使用所有 GPU。如果传入正整数列表，则仅在这些 GPU 上运行。默认情况下，它使用 CPU。
string_factory (str, 可选) — 这会传递给 Faiss 的索引工厂以创建索引。默认索引类为 IndexFlat。
metric_type (int, 可选) — 指标类型。例如：faiss.faiss.METRIC_INNER_PRODUCT 或 faiss.METRIC_L2。
custom_index (faiss.Index, 可选) — 您已实例化并根据您的需求配置的自定义 Faiss 索引。
batch_size (int, 可选) — 将向量添加到 FaissIndex 时要使用的批次大小。默认值为 1000。

在 2.4.0 版本中添加

train_size (int, 可选) — 如果索引需要训练步骤，则指定将使用多少向量来训练索引。
faiss_verbose (bool, 默认为 False) — 启用 Faiss 索引的详细模式。
dtype (numpy.dtype) — 被索引的 numpy 数组的 dtype。默认为 np.float32。

添加使用 Faiss 的密集索引以进行快速检索。索引是使用 external_arrays 的向量创建的。如果您想在 GPU 上运行它，可以指定 device（device 必须是 GPU 索引）。您可以在这里找到有关 Faiss 的更多信息

关于字符串工厂

save_faiss_index
< source >
( index_name: str file: Union storage_options: Optional = None )

参数

index_name (str) — 索引的索引名/标识符。这是用于调用 .get_nearest 或 .search 的 index_name。
file (str) — 磁盘上序列化的 faiss 索引的路径或远程 URI（例如，"s3://my-bucket/index.faiss"）。
storage_options (dict, optional) — 要传递到文件系统后端的键/值对（如果有）。

在 2.11.0 中添加

在磁盘上保存 FaissIndex。

load_faiss_index
< source >
( index_name: str file: Union device: Union = None storage_options: Optional = None )

参数

index_name (str) — 索引的索引名/标识符。这是用于调用 .get_nearest 或 .search 的 index_name。
file (str) — 磁盘上序列化的 faiss 索引的路径或远程 URI（例如，"s3://my-bucket/index.faiss"）。
device (Optional Union[int, List[int]]) — 如果是正整数，则为要使用的 GPU 的索引。如果是负整数，则使用所有 GPU。如果传入正整数列表，则仅在这些 GPU 上运行。默认情况下使用 CPU。
storage_options (dict, optional) — 要传递到文件系统后端的键/值对（如果有）。

在 2.11.0 中添加

从磁盘加载 FaissIndex。

如果您想要进行其他配置，您可以通过执行 .get_index(index_name).faiss_index 来访问 faiss 索引对象，使其满足您的需求。

add_elasticsearch_index
< source >
( column: str index_name: Optional = None host: Optional = None port: Optional = None es_client: Optional = None es_index_name: Optional = None es_index_config: Optional = None )

参数

column (str) — 要添加到索引的文档列。
index_name (str, optional) — 索引的 index_name/标识符。这是用于调用 get_nearest_examples() 或 search() 的索引名称。默认情况下，它对应于 column。
host (str, optional, defaults to localhost) — 运行 ElasticSearch 的主机。
port (str, optional, defaults to 9200) — 运行 ElasticSearch 的端口。
es_client (elasticsearch.Elasticsearch, optional) — 如果 host 和 port 为 None，则用于创建索引的 elasticsearch 客户端。
es_index_name (str, optional) — 用于创建索引的 elasticsearch 索引名称。
es_index_config (dict, optional) — elasticsearch 索引的配置。默认配置为：

使用 ElasticSearch 添加文本索引以实现快速检索。这是就地完成的。

示例

>>> es_client = elasticsearch.Elasticsearch() >>> ds = datasets.load_dataset('crime_and_punish', split='train') >>> ds.add_elasticsearch_index(column='line', es_client=es_client, es_index_name="my_es_index") >>> scores, retrieved_examples = ds.get_nearest_examples('line', 'my new query', k=10)

load_elasticsearch_index
< source >
( index_name: str es_index_name: str host: Optional = None port: Optional = None es_client: Optional = None es_index_config: Optional = None )

参数

index_name (str) — 索引的 index_name/标识符。这是用于调用 get_nearest 或 search 的索引名称。
es_index_name (str) — 要加载的 elasticsearch 索引的名称。
host (str, optional, defaults to localhost) — 运行 ElasticSearch 的主机。
port (str, optional, defaults to 9200) — 运行 ElasticSearch 的端口。
es_client (elasticsearch.Elasticsearch, optional) — 如果 host 和 port 为 None，则用于创建索引的 elasticsearch 客户端。
es_index_config (dict, optional) — elasticsearch 索引的配置。默认配置为：

使用 ElasticSearch 加载现有文本索引以实现快速检索。

list_indexes
< source >
( )

列出所有附加索引的 colindex_nameumns/标识符。

get_index
< source >
( index_name: str )

参数

index_name (str) — 索引名称。

列出所有附加索引的 index_name/标识符。

drop_index
< 源码 >
( index_name: str )

参数

index_name (str) — 索引的 index_name/标识符。

删除具有指定列的索引。

search
< 源码 >
( index_name: str query: Union k: int = 10 **kwargs ) → (scores, indices)

参数

index_name (str) — 索引的名称/标识符。
query (Union[str, np.ndarray]) — 如果 index_name 是文本索引，则查询为字符串；如果 index_name 是向量索引，则查询为 numpy 数组。
k (int) — 要检索的示例数量。

返回值

(scores, indices)

一个元组，包含 (scores, indices)，其中

scores (List[List[float]): 来自 FAISS (默认 IndexFlatL2) 或 ElasticSearch 的检索得分，针对检索到的示例

indices (List[List[int]]): 检索到的示例的索引

在数据集中查找最邻近的示例索引以进行查询。

search_batch
< 源码 >
( index_name: str queries: Union k: int = 10 **kwargs ) → (total_scores, total_indices)

参数

index_name (str) — 索引的 index_name/标识符。
queries (Union[List[str], np.ndarray]) — 如果 index_name 是文本索引，则查询为字符串列表；如果 index_name 是向量索引，则查询为 numpy 数组。
k (int) — 每个查询要检索的示例数量。

返回值

(total_scores, total_indices)

一个元组，包含 (total_scores, total_indices)，其中

total_scores (List[List[float]): 来自 FAISS (默认 IndexFlatL2) 或 ElasticSearch 的检索得分，针对每个查询检索到的示例

total_indices (List[List[int]]): 每个查询检索到的示例的索引

在数据集中查找最邻近的示例索引以进行查询。

get_nearest_examples
< 源码 >
( index_name: str query: Union k: int = 10 **kwargs ) → (scores, examples)

参数

index_name (str) — 索引的索引名称/标识符。
query (Union[str, np.ndarray]) — 如果 index_name 是文本索引，则查询为字符串；如果 index_name 是向量索引，则查询为 numpy 数组。
k (int) — 要检索的示例数量。

返回值

(scores, examples)

一个元组，包含 (scores, examples)，其中

scores (List[float]): 来自 FAISS (默认 IndexFlatL2) 或 ElasticSearch 的检索得分，针对检索到的示例

examples (dict): 检索到的示例

在数据集中查找最邻近的示例以进行查询。

get_nearest_examples_batch
< 源码 >
( index_name: str queries: Union k: int = 10 **kwargs ) → (total_scores, total_examples)

参数

index_name (str) — 索引的 index_name/标识符。
queries (Union[List[str], np.ndarray]) — 如果 index_name 是文本索引，则查询为字符串列表；如果 index_name 是向量索引，则查询为 numpy 数组。
k (int) — 每个查询要检索的示例数量。

返回值

(total_scores, total_examples)

一个元组，包含 (total_scores, total_examples)，其中

total_scores (List[List[float]): 来自 FAISS (默认 IndexFlatL2) 或 ElasticSearch 的检索得分，针对每个查询检索到的示例

total_examples (List[dict]): 每个查询检索到的示例

在数据集中查找最邻近的示例以进行查询。

info
< 源码 >
( )

DatasetInfo 对象，包含数据集中所有元数据。

split
< 源码 >
( )

NamedSplit 对象，对应于命名数据集拆分。

builder_name
< 源码 >
( )

citation
< 源码 >
( )

config_name
< 源码 >
( )

dataset_size
< 源码 >
( )

description
< source >
( )

描述
 < source >
( )

download_checksums
< source >
( )

download_size
< source >
( )

特征
 < source >
( )

主页
 < source >
( )

许可证
 < source >
( )

字节大小
 < source >
( )

监督键
 < source >
( )

版本
 < source >
( path_or_paths: Union split: Optional = None features: Optional = None cache_dir: str = None keep_in_memory: bool = False num_proc: Optional = None **kwargs )

参数

path_or_paths (path-like 或 path-like 列表) — CSV 文件的路径。
split (NamedSplit, 可选) — 要分配给数据集的拆分名称。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
num_proc (int, 可选, 默认为 None) — 在本地下载和生成数据集时，进程数。如果数据集由多个文件组成，这将很有帮助。默认情况下禁用多处理。

在 2.8.0 版本中添加

**kwargs (附加关键字参数) — 要传递给 pandas.read_csv 的关键字参数。

从 CSV 文件创建数据集。

示例

>>> ds = Dataset.from_csv('path/to/dataset.csv')

from_json
< source >
( path_or_paths: Union split: Optional = None features: Optional = None cache_dir: str = None keep_in_memory: bool = False field: Optional = None num_proc: Optional = None **kwargs )

参数

path_or_paths (path-like 或 path-like 列表) — JSON 或 JSON Lines 文件的路径。
split (NamedSplit, 可选) — 要分配给数据集的拆分名称。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
field (str, 可选) — JSON 文件中包含数据集的字段名称。
num_proc (int, 可选默认为 None) — 在本地下载和生成数据集时，进程数。如果数据集由多个文件组成，这将很有帮助。默认情况下禁用多处理。

在 2.8.0 版本中添加

**kwargs (附加关键字参数) — 要传递给 JsonConfig 的关键字参数。

从 JSON 或 JSON Lines 文件创建数据集。

示例

>>> ds = Dataset.from_json('path/to/dataset.json')

from_parquet
< source >
( path_or_paths: Union split: Optional = None features: Optional = None cache_dir: str = None keep_in_memory: bool = False columns: Optional = None num_proc: Optional = None **kwargs )

参数

path_or_paths (path-like 或 path-like 列表) — Parquet 文件的路径。
split (NamedSplit, 可选) — 要分配给数据集的拆分名称。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
columns (List[str], 可选) — 如果不为 None，则仅从文件中读取这些列。列名可以是嵌套字段的前缀，例如 ‘a’ 将选择 ‘a.b’、‘a.c’ 和 ‘a.d.e’。
num_proc (int, 可选, 默认为 None) — 本地下载和生成数据集时的进程数。如果数据集由多个文件组成，这将很有帮助。默认情况下禁用多进程。

在 2.8.0 版本中添加

**kwargs (附加关键字参数) — 要传递给 ParquetConfig 的关键字参数。

从 Parquet 文件创建数据集。

示例

>>> ds = Dataset.from_parquet('path/to/dataset.parquet')

from_text
< source >
( path_or_paths: Union split: Optional = None features: Optional = None cache_dir: str = None keep_in_memory: bool = False num_proc: Optional = None **kwargs )

参数

path_or_paths (path-like 或 path-like 列表) — 文本文件的路径。
split (NamedSplit, 可选) — 要分配给数据集的拆分名称。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
num_proc (int, 可选, 默认为 None) — 本地下载和生成数据集时的进程数。如果数据集由多个文件组成，这将很有帮助。默认情况下禁用多进程。

在 2.8.0 版本中添加

**kwargs (附加关键字参数) — 要传递给 TextConfig 的关键字参数。

从文本文件创建数据集。

示例

>>> ds = Dataset.from_text('path/to/dataset.txt')

from_sql
< source >
( sql: Union con: Union features: Optional = None cache_dir: str = None keep_in_memory: bool = False **kwargs )

参数

sql (str 或 sqlalchemy.sql.Selectable) — 要执行的 SQL 查询或表名。
con (str 或 sqlite3.Connection 或 sqlalchemy.engine.Connection 或 sqlalchemy.engine.Connection) — 用于实例化数据库连接的 URI 字符串或 SQLite3/SQLAlchemy 连接对象。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
**kwargs (附加关键字参数) — 要传递给 SqlConfig 的关键字参数。

从 SQL 查询或数据库表创建数据集。

示例

>>> # Fetch a database table >>> ds = Dataset.from_sql("test_data", "postgres:///db_name") >>> # Execute a SQL query on the table >>> ds = Dataset.from_sql("SELECT sentence FROM test_data", "postgres:///db_name") >>> # Use a Selectable object to specify the query >>> from sqlalchemy import select, text >>> stmt = select([text("sentence")]).select_from(text("test_data")) >>> ds = Dataset.from_sql(stmt, "postgres:///db_name")

仅当 con 指定为 URI 字符串时，返回的数据集才能被缓存。

align_labels_with_mapping
< source >
( label2id: Dict label_column: str )

参数

label2id (dict) — 要与数据集对齐的标签名称到 ID 的映射。
label_column (str) — 要对齐的标签的列名。

将数据集的标签 ID 和标签名称映射对齐，以匹配输入的 label2id 映射。当您想要确保模型的预测标签与数据集对齐时，这非常有用。对齐是使用小写的标签名称完成的。

示例

>>> # dataset with mapping {'entailment': 0, 'neutral': 1, 'contradiction': 2} >>> ds = load_dataset("glue", "mnli", split="train") >>> # mapping to align with >>> label2id = {'CONTRADICTION': 0, 'NEUTRAL': 1, 'ENTAILMENT': 2} >>> ds_aligned = ds.align_labels_with_mapping(label2id, "label")

datasets.concatenate_datasets
< source >
( dsets: List info: Optional = None split: Optional = None axis: int = 0 )

参数

dsets (List[datasets.Dataset]) — 要连接的数据集列表。
info (DatasetInfo, 可选) — 数据集信息，例如描述、引用等。
split (NamedSplit, 可选) — 数据集拆分的名称。
axis ({0, 1}, 默认为 0) — 要在其上连接的轴，其中 0 表示按行（垂直）连接，1 表示按列（水平）连接。

在 1.6.0 版本中添加

将具有相同模式的 Dataset 列表转换为单个 Dataset。

示例

>>> ds3 = concatenate_datasets([ds1, ds2])

datasets.interleave_datasets
< source >
( datasets: List probabilities: Optional = None seed: Optional = None info: Optional = None split: Optional = None stopping_strategy: Literal = 'first_exhausted' ) → Dataset 或 IterableDataset

参数

datasets (List[Dataset] 或 List[IterableDataset]) — 要交错的数据集列表。
probabilities (List[float], 可选, 默认为 None) — 如果指定，则新的数据集将通过根据这些概率一次从一个源中抽样示例来构建。
seed (int, 可选, 默认为 None) — 用于为每个示例选择源的随机种子。
info (DatasetInfo, 可选) — 数据集信息，例如描述、引文等。

在 2.4.0 版本中添加

split (NamedSplit, 可选) — 数据集拆分的名称。

在 2.4.0 版本中添加

stopping_strategy (str, 默认为 first_exhausted) — 现在提出了两种策略，first_exhausted 和 all_exhausted。默认情况下，first_exhausted 是一种欠采样策略，即只要一个数据集用完样本，数据集构建就会停止。如果策略是 all_exhausted，我们使用过采样策略，即只要每个数据集的每个样本都至少添加一次，数据集构建就会停止。请注意，如果策略是 all_exhausted，则交错数据集的大小可能会变得非常大：

在没有概率的情况下，生成的数据集将具有 max_length_datasets*nb_dataset 个样本。

在给定概率的情况下，如果某些数据集的访问概率非常低，则生成的数据集将具有更多样本。

返回值

Dataset 或 IterableDataset

返回类型取决于输入 datasets 参数。如果输入是 Dataset 列表，则返回 Dataset；如果输入是 IterableDataset 列表，则返回 IterableDataset。

将多个数据集（源）交错到单个数据集中。新的数据集通过在源之间交替以获取示例来构建。

您可以在 Dataset 对象列表或 IterableDataset 对象列表上使用此函数。

如果 probabilities 为 None（默认），则通过在每个源之间循环以获取示例来构建新的数据集。

如果 probabilities 不为 None，则通过根据提供的概率，一次从随机源获取示例来构建新的数据集。

当其中一个源数据集用完示例时，结果数据集结束，除非 oversampling 为 True，在这种情况下，当所有数据集都至少用完一次示例时，结果数据集结束。

可迭代数据集的注意事项

在分布式设置或 PyTorch DataLoader 工作进程中，停止策略应用于每个进程。因此，分片可迭代数据集上的“first_exhausted”策略可能会生成更少的总样本（每个子数据集每个工作进程最多 1 个缺失样本）。

示例

对于常规数据集（map-style）

>>> from datasets import Dataset, interleave_datasets >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22]}) >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 10, 0, 1, 2, 21, 0, 11, 1, 2, 0, 1, 12, 2, 10, 0, 22] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> d1 = Dataset.from_dict({"a": [0, 1, 2]}) >>> d2 = Dataset.from_dict({"a": [10, 11, 12, 13]}) >>> d3 = Dataset.from_dict({"a": [20, 21, 22, 23, 24]}) >>> dataset = interleave_datasets([d1, d2, d3]) >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22] >>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted") >>> dataset["a"] [0, 10, 20, 1, 11, 21, 2, 12, 22, 0, 13, 23, 1, 10, 24] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42) >>> dataset["a"] [10, 0, 11, 1, 2] >>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted") >>> dataset["a"] [10, 0, 11, 1, 2, 20, 12, 13, ..., 0, 1, 2, 0, 24] For datasets in streaming mode (iterable): >>> from datasets import load_dataset, interleave_datasets >>> d1 = load_dataset("oscar", "unshuffled_deduplicated_en", split="train", streaming=True) >>> d2 = load_dataset("oscar", "unshuffled_deduplicated_fr", split="train", streaming=True) >>> dataset = interleave_datasets([d1, d2]) >>> iterator = iter(dataset) >>> next(iterator) {'text': 'Mtendere Village was inspired by the vision...} >>> next(iterator) {'text': "Média de débat d'idées, de culture...}

datasets.distributed.split_dataset_by_node
< source >
( dataset: DatasetType rank: int world_size: int ) → Dataset 或 IterableDataset

参数

dataset (Dataset 或 IterableDataset) — 要按节点拆分的数据集。
rank (int) — 当前节点的排名。
world_size (int) — 节点总数。

返回值

Dataset 或 IterableDataset

要在排名为 rank 的节点上使用的数据集。

在大小为 world_size 的节点池中，为排名为 rank 的节点拆分数据集。

对于 map-style 数据集

每个节点都分配有一个数据块，例如，排名 0 的节点被赋予数据集的第一个块。为了最大化数据加载吞吐量，如果可能，块由磁盘上的连续数据组成。

对于可迭代数据集

如果数据集的分片数是 world_size 的因子（即，如果 dataset.n_shards % world_size == 0），则分片在节点之间均匀分配，这是最优化的。否则，每个节点保留 world_size 分之一的示例，跳过其他示例。

datasets.enable_caching
< source >
( )

当对数据集应用转换时，数据存储在缓存文件中。缓存机制允许重新加载现有的缓存文件（如果已计算）。

重新加载数据集是可能的，因为缓存文件使用数据集指纹命名，该指纹在每次转换后都会更新。

如果禁用，则在将转换应用于数据集时，库将不再重新加载缓存的数据集文件。更准确地说，如果禁用缓存

缓存文件始终重新创建

缓存文件写入临时目录，该目录在会话关闭时删除

缓存文件使用随机哈希而不是数据集指纹命名

使用 save_to_disk() 保存转换后的数据集，否则它将在会话关闭时删除

缓存不影响 load_dataset()。如果要从头开始重新生成数据集，则应在 load_dataset() 中使用 download_mode 参数。

datasets.disable_caching
< source >
( )

当对数据集应用转换时，数据存储在缓存文件中。缓存机制允许重新加载现有的缓存文件（如果已计算）。

重新加载数据集是可能的，因为缓存文件使用数据集指纹命名，该指纹在每次转换后都会更新。

如果禁用，则在将转换应用于数据集时，库将不再重新加载缓存的数据集文件。更准确地说，如果禁用缓存

缓存文件始终重新创建

缓存文件写入临时目录，该目录在会话关闭时删除

缓存文件使用随机哈希而不是数据集指纹命名

使用 save_to_disk() 保存转换后的数据集，否则它将在会话关闭时删除

缓存不影响 load_dataset()。如果要从头开始重新生成数据集，则应在 load_dataset() 中使用 download_mode 参数。

datasets.is_caching_enabled
< source >
( )

当对数据集应用转换时，数据存储在缓存文件中。缓存机制允许重新加载现有的缓存文件（如果已计算）。

重新加载数据集是可能的，因为缓存文件使用数据集指纹命名，该指纹在每次转换后都会更新。

如果禁用，则在将转换应用于数据集时，库将不再重新加载缓存的数据集文件。更准确地说，如果禁用缓存

缓存文件始终重新创建

缓存文件写入临时目录，该目录在会话关闭时删除

缓存文件使用随机哈希而不是数据集指纹命名

使用 save_to_disk()] 保存转换后的数据集，否则它将在会话关闭时删除

缓存不影响 load_dataset()。如果要从头开始重新生成数据集，则应在 load_dataset() 中使用 download_mode 参数。

DatasetDict

字典，其中拆分名称作为键（例如“train”、“test”），Dataset 对象作为值。它还具有数据集转换方法，如 map 或 filter，可一次处理所有拆分。

class datasets.DatasetDict
< source >
( )

带有数据集转换方法（map、filter 等）的字典（str: datasets.Dataset 的字典）

data
< source >
( )

支持每个拆分的 Apache Arrow 表。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.data

cache_files
< source >
( )

包含支持每个拆分的 Apache Arrow 表的缓存文件。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.cache_files {'test': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-test.arrow'}], 'train': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-train.arrow'}], 'validation': [{'filename': '/root/.cache/huggingface/datasets/rotten_tomatoes_movie_review/default/1.0.0/40d411e45a6ce3484deed7cc15b82a53dad9a72aafd9f86f8f227134bec5ca46/rotten_tomatoes_movie_review-validation.arrow'}]}

num_columns
< source >
( )

数据集中每个拆分的列数。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.num_columns {'test': 2, 'train': 2, 'validation': 2}

num_rows
< source >
( )

数据集中每个拆分的行数。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.num_rows {'test': 1066, 'train': 8530, 'validation': 1066}

column_names
< source >
( )

数据集中每个拆分的列名。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.column_names {'test': ['text', 'label'], 'train': ['text', 'label'], 'validation': ['text', 'label']}

shape
< source >
( )

数据集每个拆分部分的形状（行数，列数）。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.shape {'test': (1066, 2), 'train': (8530, 2), 'validation': (1066, 2)}

unique
< source >
( column: str ) → Dict[str, list]

参数

column (str) — 列名（使用 column_names 列出所有列名）

返回值

Dict[str, list]

给定列中唯一元素的字典。

返回每个拆分部分中列的唯一元素列表。

这是在底层后端实现的，因此速度非常快。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.unique("label") {'test': [1, 0], 'train': [1, 0], 'validation': [1, 0]}

cleanup_cache_files
< source >
( )

清理数据集缓存目录中的所有缓存文件，但当前正在使用的缓存文件（如果存在）除外。运行此命令时请注意，没有其他进程正在使用其他缓存文件。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.cleanup_cache_files() {'test': 0, 'train': 0, 'validation': 0}

map
< source >
( function: Optional = None with_indices: bool = False with_rank: bool = False input_columns: Union = None batched: bool = False batch_size: Optional = 1000 drop_last_batch: bool = False remove_columns: Union = None keep_in_memory: bool = False load_from_cache_file: Optional = None cache_file_names: Optional = None writer_batch_size: Optional = 1000 features: Optional = None disable_nullable: bool = False fn_kwargs: Optional = None num_proc: Optional = None desc: Optional = None )

参数

function (callable) — 具有以下签名之一的函数：

function(example: Dict[str, Any]) -> Dict[str, Any] 如果 batched=False 且 with_indices=False

function(example: Dict[str, Any], indices: int) -> Dict[str, Any] 如果 batched=False 且 with_indices=True

function(batch: Dict[str, List]) -> Dict[str, List] 如果 batched=True 且 with_indices=False

function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List] 如果 batched=True 且 with_indices=True

对于高级用法，该函数还可以返回一个 pyarrow.Table。此外，如果您的函数不返回任何内容 (None)，则 map 将运行您的函数并返回未更改的数据集。
with_indices (bool, 默认为 False) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 def function(example, idx): ...。
with_rank (bool, 默认为 False) — 向 function 提供进程排名。请注意，在这种情况下，function 的签名应为 def function(example[, idx], rank): ...。
input_columns ([Union[str, List[str]]], 可选, 默认为 None) — 要作为位置参数传递到 function 中的列。如果为 None，则将映射到所有格式化列的字典作为单个参数传递。
batched (bool, 默认为 False) — 向 function 提供示例批次。
batch_size (int, 可选, 默认为 1000) — 如果 batched=True，则提供给 function 的每个批次的示例数，batch_size <= 0 或 batch_size == None，然后将完整数据集作为单个批次提供给 function。
drop_last_batch (bool, 默认为 False) — 是否应丢弃小于 batch_size 的最后一个批次，而不是由函数处理。
remove_columns ([Union[str, List[str]]], 可选, 默认为 None) — 在执行映射时删除选择的列。列将在使用 function 的输出更新示例之前删除，即，如果 function 正在添加名称在 remove_columns 中的列，则将保留这些列。
keep_in_memory (bool, 默认为 False) — 将数据集保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], 如果启用缓存，则默认为 True) — 如果可以识别出存储来自 function 的当前计算的缓存文件，则使用它而不是重新计算。
cache_file_names ([Dict[str, str]], 可选, 默认为 None) — 提供缓存文件的路径名称。它用于存储计算结果，而不是自动生成的缓存文件名。您必须为数据集字典中的每个数据集提供一个 cache_file_name。
writer_batch_size (int, 默认为 1000) — 缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间的良好折衷。较高的值使处理执行更少的查找，较低的值在运行 map 时消耗更少的临时内存。
features ([datasets.Features], 可选, 默认为 None) — 使用特定的 Features 来存储缓存文件，而不是自动生成的文件。
disable_nullable (bool, 默认为 False) — 不允许表中的空值。
fn_kwargs (Dict, 可选, 默认为 None) — 要传递给 function 的关键字参数
num_proc (int, 可选, 默认为 None) — 用于多处理的进程数。默认情况下，它不使用多处理。
desc (str, 可选, 默认为 None) — 有意义的描述，与映射示例时的进度条一起显示。

将函数应用于表中的所有元素（单独或批量），并更新表（如果函数更新了示例）。转换应用于数据集字典的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> ds["train"][0:3]["text"] ['Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .', 'Review: effective but too-tepid biopic'] # process a batch of examples >>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True) # set number of processors >>> ds = ds.map(add_prefix, num_proc=4)

filter
< source >
( function: Optional = None with_indices: bool = False with_rank: bool = False input_columns: Union = None batched: bool = False batch_size: Optional = 1000 keep_in_memory: bool = False load_from_cache_file: Optional = None cache_file_names: Optional = None writer_batch_size: Optional = 1000 fn_kwargs: Optional = None num_proc: Optional = None desc: Optional = None )

参数

function (Callable) — 具有以下签名之一的可调用对象：

function(example: Dict[str, Any]) -> bool 如果 batched=False 且 with_indices=False 且 with_rank=False

function(example: Dict[str, Any], *extra_args) -> bool 如果 batched=False 且 with_indices=True 和/或 with_rank=True （每个参数一个额外参数）

function(batch: Dict[str, List]) -> List[bool] 如果 batched=True 且 with_indices=False 且 with_rank=False

function(batch: Dict[str, List], *extra_args) -> List[bool] 如果 batched=True 且 with_indices=True 和/或 with_rank=True （每个参数一个额外参数）

如果没有提供函数，则默认为始终返回 True 的函数：lambda x: True。
with_indices (bool, defaults to False) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 def function(example, idx[, rank]): ...。
with_rank (bool, defaults to False) — 向 function 提供进程 rank。请注意，在这种情况下，function 的签名应为 def function(example[, idx], rank): ...。
input_columns ([Union[str, List[str]]], 可选, defaults to None) — 要作为位置参数传递到 function 中的列。如果为 None，则将映射到所有格式化列的字典作为单个参数传递。
batched (bool, defaults to False) — 向 function 提供一批示例。
batch_size (int, 可选, defaults to 1000) — 如果 batched=True，则提供给 function 的每个批次的示例数。 batch_size <= 0 或 batch_size == None 则将完整数据集作为单个批次提供给 function。
keep_in_memory (bool, defaults to False) — 将数据集保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], defaults to True if caching is enabled) — 如果可以识别出存储来自 function 的当前计算的缓存文件，则使用它而不是重新计算。
cache_file_names ([Dict[str, str]], 可选, defaults to None) — 提供缓存文件的路径名称。它用于存储计算结果，而不是自动生成的缓存文件名。您必须为数据集字典中的每个数据集提供一个 cache_file_name。
writer_batch_size (int, defaults to 1000) — 缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间取得良好平衡。较高的值使处理执行较少的查找，较低的值在运行 map 时消耗较少的临时内存。
fn_kwargs (Dict, 可选, defaults to None) — 要传递给 function 的关键字参数
num_proc (int, 可选, defaults to None) — 用于多进程处理的进程数。默认情况下，它不使用多进程处理。
desc (str, 可选, defaults to None) — 在过滤示例时与进度条一起显示的有意义的描述。

将过滤器函数批量应用于表中的所有元素，并更新表，使数据集仅包含符合过滤器函数的示例。此转换应用于数据集字典的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.filter(lambda x: x["label"] == 1) DatasetDict({ train: Dataset({ features: ['text', 'label'], num_rows: 4265 }) validation: Dataset({ features: ['text', 'label'], num_rows: 533 }) test: Dataset({ features: ['text', 'label'], num_rows: 533 }) })

sort
< source >
( column_names: Union reverse: Union = False null_placement: str = 'at_end' keep_in_memory: bool = False load_from_cache_file: Optional = None indices_cache_file_names: Optional = None writer_batch_size: Optional = 1000 )

参数

column_names (Union[str, Sequence[str]]) — 要排序的列名。
reverse (Union[bool, Sequence[bool]], defaults to False) — 如果为 True，则按降序而不是升序排序。如果提供单个布尔值，则该值将应用于所有列名的排序。否则，必须提供与 column_names 长度和顺序相同的布尔值列表。
null_placement (str, defaults to at_end) — 将 None 值放在开头（如果为 at_start 或 first），或放在结尾（如果为 at_end 或 last）
keep_in_memory (bool, defaults to False) — 将排序后的索引保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], defaults to True if caching is enabled) — 如果可以识别出存储排序索引的缓存文件，则使用它而不是重新计算。
indices_cache_file_names ([Dict[str, str]], 可选, defaults to None) — 提供缓存文件的路径名称。它用于存储索引映射，而不是自动生成的缓存文件名。您必须为数据集字典中的每个数据集提供一个 cache_file_name。
writer_batch_size (int, defaults to 1000) — 缓存文件写入器的每次写入操作的行数。较高的值会产生较小的缓存文件，较低的值会消耗较少的临时内存。

创建一个新数据集，该数据集根据单个或多个列排序。

示例

>>> from datasets import load_dataset >>> ds = load_dataset('rotten_tomatoes') >>> ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] >>> sorted_ds = ds.sort('label') >>> sorted_ds['train']['label'][:10] [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] >>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False]) >>> another_sorted_ds['train']['label'][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

shuffle
< source >
( seeds: Union = None seed: Optional = None generators: Optional = None keep_in_memory: bool = False load_from_cache_file: Optional = None indices_cache_file_names: Optional = None writer_batch_size: Optional = 1000 )

参数

seeds (Dict[str, int] or int, 可选) — 如果 generator=None，则用于初始化默认 BitGenerator 的种子。如果为 None，则将从操作系统中提取新的、不可预测的熵。如果传递 int 或 array_like[ints]，则会将其传递给 SeedSequence 以导出初始 BitGenerator 状态。您可以为数据集字典中的每个数据集提供一个 seed。
seed (int, 可选) — 如果 generator=None，则用于初始化默认 BitGenerator 的种子。seeds 的别名（如果同时提供两者，则会引发 ValueError）。
generators (Dict[str, *optional*, np.random.Generator]) — Numpy 随机 Generator，用于计算数据集行的排列。如果 generator=None（默认），则使用 np.random.default_rng（NumPy 的默认 BitGenerator (PCG64)）。您必须为数据集字典中的每个数据集提供一个 generator。
keep_in_memory (bool, defaults to False) — 将数据集保存在内存中，而不是写入缓存文件。
load_from_cache_file (Optional[bool], defaults to True if caching is enabled) — 如果可以找到缓存文件来存储来自 function 的当前计算结果，则使用它而不是重新计算（默认为 True，如果启用了缓存）。
indices_cache_file_names (Dict[str, str], 可选) — 提供缓存文件的路径名称。它用于存储索引映射，而不是自动生成的缓存文件名。您必须为数据集字典中的每个数据集提供一个 cache_file_name。
writer_batch_size (int, defaults to 1000) — 用于缓存文件写入器的每次写入操作的行数。此值是在处理期间的内存使用量和处理速度之间取得良好平衡。较高的值使处理执行更少的查找，较低的值在运行 map 时消耗更少的临时内存。

创建一个新 Dataset，其中的行已被打乱顺序。

转换将应用于数据集字典的所有数据集。

当前，打乱顺序使用 numpy 随机生成器。您可以提供要使用的 NumPy BitGenerator，或提供一个种子来初始化 NumPy 的默认随机生成器 (PCG64)。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds["train"]["label"][:10] [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] # set a seed >>> shuffled_ds = ds.shuffle(seed=42) >>> shuffled_ds["train"]["label"][:10] [0, 1, 0, 1, 0, 0, 0, 0, 0, 0]

set_format
< source >
( type: Optional = None columns: Optional = None output_all_columns: bool = False **format_kwargs )

参数

type (str, 可选) — 在 [None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax'] 中选择的输出类型。None 表示 __getitem__ 返回 python 对象（默认）。
columns (List[str], 可选) — 要在输出中格式化的列。None 表示 __getitem__ 返回所有列（默认）。
output_all_columns (bool, defaults to False) — 在输出中也保留未格式化的列（作为 python 对象），默认为 False。
**format_kwargs (附加的关键字参数) — 传递给转换函数的关键字参数，例如 np.array、torch.tensor 或 tensorflow.ragged.constant。

设置 __getitem__ 返回格式（类型和列）。格式为数据集字典中的每个数据集设置。

可以在调用 set_format 后调用 map。由于 map 可能会添加新列，因此格式化列的列表会更新。在这种情况下，如果您在数据集上应用 map 以添加新列，则将格式化此列

新的格式化列 = （所有列 - 先前未格式化的列）

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'}

reset_format
< source >
( )

将 __getitem__ 返回格式重置为 python 对象和所有列。转换将应用于数据集字典的所有数据集。

与 self.set_format() 相同

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x["text"], truncation=True, padding=True), batched=True) >>> ds.set_format(type="numpy", columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'numpy'} >>> ds.reset_format() >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None}

formatted_as
< source >
( type: Optional = None columns: Optional = None output_all_columns: bool = False **format_kwargs )

参数

type (str, 可选) — 在 [None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax'] 中选择的输出类型。None 表示 __getitem__ 返回 python 对象（默认）。
columns (List[str], 可选) — 要在输出中格式化的列。None 表示 __getitem__ 返回所有列（默认）。
output_all_columns (bool, defaults to False) — 在输出中也保留未格式化的列（作为 python 对象）。
**format_kwargs (附加的关键字参数) — 传递给转换函数的关键字参数，例如 np.array、torch.tensor 或 tensorflow.ragged.constant。

用于 with 语句中。设置 __getitem__ 返回格式（类型和列）。转换将应用于数据集字典的所有数据集。

with_format
< source >
( type: Optional = None columns: Optional = None output_all_columns: bool = False **format_kwargs )

参数

type (str, 可选) — 在 [None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow', 'jax'] 中选择的输出类型。None 表示 __getitem__ 返回 python 对象（默认）。
columns (List[str], 可选) — 要在输出中格式化的列。None 表示 __getitem__ 返回所有列（默认）。
output_all_columns (bool, defaults to False) — 在输出中也保留未格式化的列（作为 python 对象）。
**format_kwargs (附加的关键字参数) — 传递给转换函数的关键字参数，例如 np.array、torch.tensor 或 tensorflow.ragged.constant。

设置 __getitem__ 返回格式（类型和列）。数据格式化是即时应用的。格式 type （例如 “numpy”）用于在使用 __getitem__ 时格式化批次。格式为数据集字典中的每个数据集设置。

也可以使用自定义转换进行格式化，方法是使用 with_transform()。

与 set_format() 相反，with_format 返回一个新的 DatasetDict 对象，其中包含新的 Dataset 对象。

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True) >>> ds["train"].format {'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'], 'format_kwargs': {}, 'output_all_columns': False, 'type': None} >>> ds = ds.with_format(type='tensorflow', columns=['input_ids', 'token_type_ids', 'attention_mask', 'label']) >>> ds["train"].format {'columns': ['input_ids', 'token_type_ids', 'attention_mask', 'label'], 'format_kwargs': {}, 'output_all_columns': False, 'type': 'tensorflow'}

with_transform
< source >
( transform: Optional columns: Optional = None output_all_columns: bool = False )

参数

transform (Callable, 可选) — 用户定义的格式化转换，替换由 set_format() 定义的格式。格式化函数是一个可调用对象，它接受一个批次（作为字典）作为输入并返回一个批次。此函数在 __getitem__ 中返回对象之前立即应用。
columns (List[str], 可选) — 要在输出中格式化的列。如果指定，则转换的输入批次仅包含这些列。
output_all_columns (bool, defaults to False) — 在输出中也保留未格式化的列（作为 python 对象）。如果设置为 True，则其他未格式化的列将与转换的输出一起保留。

使用此转换设置 __getitem__ 返回格式。当调用 __getitem__ 时，转换会即时应用于批次。转换是为数据集字典中的每个数据集设置的

与 set_format() 类似，可以使用 reset_format() 重置此格式。

与 set_transform() 相反，with_transform 返回一个新的 DatasetDict 对象，其中包含新的 Dataset 对象。

示例

>>> from datasets import load_dataset >>> from transformers import AutoTokenizer >>> ds = load_dataset("rotten_tomatoes") >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") >>> def encode(example): ... return tokenizer(example['text'], truncation=True, padding=True, return_tensors="pt") >>> ds = ds.with_transform(encode) >>> ds["train"][0] {'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), 'input_ids': tensor([ 101, 1103, 2067, 1110, 17348, 1106, 1129, 1103, 6880, 1432, 112, 188, 1207, 107, 14255, 1389, 107, 1105, 1115, 1119, 112, 188, 1280, 1106, 1294, 170, 24194, 1256, 3407, 1190, 170, 11791, 5253, 188, 1732, 7200, 10947, 12606, 2895, 117, 179, 7766, 118, 172, 15554, 1181, 3498, 6961, 3263, 1137, 188, 1566, 7912, 14516, 6997, 119, 102]), 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}

flatten
< source >
( max_depth = 16 )

展平每个拆分的 Apache Arrow 表（嵌套特征将被展平）。具有结构类型的每列都将展平为每个结构字段一列。其他列保持不变。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("squad") >>> ds["train"].features {'answers': Sequence(feature={'text': Value(dtype='string', id=None), 'answer_start': Value(dtype='int32', id=None)}, length=-1, id=None), 'context': Value(dtype='string', id=None), 'id': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None), 'title': Value(dtype='string', id=None)} >>> ds.flatten() DatasetDict({ train: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 87599 }) validation: Dataset({ features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'], num_rows: 10570 }) })

cast
< source >
( features：Features )

参数

features (Features) — 用于将数据集转换为的新特征。特征中字段的名称和顺序必须与当前的列名匹配。数据类型也必须可以相互转换。对于非平凡的转换，例如 string <-> ClassLabel，您应该使用 map() 来更新数据集。

将数据集转换为一组新的特征。此转换应用于数据集字典的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='large_string', id=None)}

cast_column
< source >
( column: str feature )

参数

column (str) — 列名。
feature (Feature) — 目标特征。

将列转换为特征以进行解码。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='string', id=None)}

remove_columns
< source >
( column_names: Union ) → DatasetDict

参数

column_names (Union[str, List[str]]) — 要删除的列名。

返回值

DatasetDict

不包含要删除的列的数据集对象的副本。

从数据集的每个拆分中删除一列或多列，以及与列关联的特征。

此转换应用于数据集字典的所有拆分。

您还可以使用 map() 和 remove_columns 删除列，但当前方法不会复制剩余列的数据，因此速度更快。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds = ds.remove_columns("label") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) })

rename_column
< source >
( original_column_name: str new_column_name: str )

参数

original_column_name (str) — 要重命名的列的名称。
new_column_name (str) — 列的新名称。

重命名数据集中的一列，并将与原始列关联的特征移动到新列名下。此转换应用于数据集字典的所有数据集。

您还可以使用 map() 和 remove_columns 重命名列，但当前方法

负责将原始特征移动到新列名下。

不会将数据复制到新数据集，因此速度更快得多。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds = ds.rename_column("label", "label_new") DatasetDict({ train: Dataset({ features: ['text', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text', 'label_new'], num_rows: 1066 }) })

rename_columns
< source >
( column_mapping: Dict ) → DatasetDict

参数

column_mapping (Dict[str, str]) — 列到新名称的映射字典。

返回值

DatasetDict

具有重命名列的数据集副本。

重命名数据集中的多个列，并将与原始列关联的特征移动到新列名下。此转换应用于数据集字典的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.rename_columns({'text': 'text_new', 'label': 'label_new'}) DatasetDict({ train: Dataset({ features: ['text_new', 'label_new'], num_rows: 8530 }) validation: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) test: Dataset({ features: ['text_new', 'label_new'], num_rows: 1066 }) })

select_columns
< source >
( column_names: Union )

参数

column_names (Union[str, List[str]]) — 要保留的列名。

从数据集的每个拆分中选择一列或多列，以及与列关联的特征。

此转换应用于数据集字典的所有拆分。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes") >>> ds.select_columns("text") DatasetDict({ train: Dataset({ features: ['text'], num_rows: 8530 }) validation: Dataset({ features: ['text'], num_rows: 1066 }) test: Dataset({ features: ['text'], num_rows: 1066 }) })

class_encode_column
< source >
( column: str include_nulls: bool = False )

参数

column (str) — 要转换的列的名称。
include_nulls (bool, 默认为 False) — 是否在类标签中包含空值。如果为 True，则空值将编码为 "None" 类标签。

在 1.14.2 版本中添加

将给定列转换为 ClassLabel 并更新表。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("boolq") >>> ds["train"].features {'answer': Value(dtype='bool', id=None), 'passage': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None)} >>> ds = ds.class_encode_column("answer") >>> ds["train"].features {'answer': ClassLabel(num_classes=2, names=['False', 'True'], id=None), 'passage': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None)}

push_to_hub
< source >
( repo_id config_name: str = 'default' set_default: Optional = None data_dir: Optional = None commit_message: Optional = None commit_description: Optional = None private: Optional = False token: Optional = None revision: Optional = None create_pr: Optional = False max_shard_size: Union = None num_shards: Optional = None embed_external_files: bool = True )

参数

repo_id (str) — 要推送到的仓库的 ID，格式如下：<user>/<dataset_name> 或 <org>/<dataset_name>。也接受 <dataset_name>，这将默认为已登录用户的命名空间。
config_name (str) — 数据集的配置名称。默认为 “default”。
set_default (bool, 可选) — 是否将此配置设置为默认配置。否则，默认配置是名为 “default” 的配置。
data_dir (str, 可选) — 将包含上传的数据文件的目录名称。如果与 “default” 不同，则默认为 config_name，否则为 “data”。

在 2.17.0 版本中添加

commit_message (str, 可选) — 推送时要提交的消息。将默认为 "Upload dataset"。
commit_description (str, 可选) — 将要创建的提交的描述。此外，如果创建了 PR（create_pr 为 True），则为 PR 的描述。

在 2.16.0 版本中添加

private (bool, 可选) — 数据集仓库是否应设置为私有。仅影响仓库创建：已存在的仓库不受此参数影响。
token (str, 可选) — 用于 Hugging Face Hub 的可选身份验证令牌。如果未传递令牌，则默认为使用 huggingface-cli login 登录时本地保存的令牌。如果未传递令牌且用户未登录，则会引发错误。
revision (str, 可选) — 将上传的文件推送到的分支。默认为 "main" 分支。

在 2.15.0 版本中添加

create_pr (bool, 可选, 默认为 False) — 是否使用上传的文件创建 PR 或直接提交。

在 2.15.0 版本中添加

max_shard_size (int 或 str, 可选, 默认为 "500MB") — 上传到 hub 的数据集分片的最大大小。如果表示为字符串，则需要是数字后跟单位（例如 "500MB" 或 "1GB"）。
num_shards (Dict[str, int], 可选) — 要写入的分片数量。默认情况下，分片数量取决于 max_shard_size。使用字典为每个拆分定义不同的 num_shards。

在 2.8.0 版本中添加

embed_external_files (bool, 默认为 True) — 是否将文件字节嵌入到分片中。特别是，这将在推送之前对以下类型的字段执行以下操作：

Audio 和 Image 删除本地路径信息并将文件内容嵌入到 Parquet 文件中。

将 DatasetDict 作为 Parquet 数据集推送到 hub。 DatasetDict 使用 HTTP 请求推送，并且不需要安装 git 或 git-lfs。

每个数据集拆分将独立推送。推送的数据集将保留原始拆分名称。

默认情况下，生成的 Parquet 文件是自包含的：如果您的数据集包含 Image 或 Audio 数据，则 Parquet 文件将存储您的图像或音频文件的字节。您可以通过将 embed_external_files 设置为 False 来禁用此功能。

示例

>>> dataset_dict.push_to_hub("<organization>/<dataset_id>") >>> dataset_dict.push_to_hub("<organization>/<dataset_id>", private=True) >>> dataset_dict.push_to_hub("<organization>/<dataset_id>", max_shard_size="1GB") >>> dataset_dict.push_to_hub("<organization>/<dataset_id>", num_shards={"train": 1024, "test": 8})

如果您想向数据集添加新的配置（或子集）（例如，如果数据集有多个任务/版本/语言）

>>> english_dataset.push_to_hub("<organization>/<dataset_id>", "en") >>> french_dataset.push_to_hub("<organization>/<dataset_id>", "fr") >>> # later >>> english_dataset = load_dataset("<organization>/<dataset_id>", "en") >>> french_dataset = load_dataset("<organization>/<dataset_id>", "fr")

save_to_disk
< source >
( dataset_dict_path: Union max_shard_size: Union = None num_shards: Optional = None num_proc: Optional = None storage_options: Optional = None )

参数

dataset_dict_path (path-like) — 数据集字典目录的路径（例如 dataset/train）或远程 URI（例如 s3://my-bucket/dataset/train），数据集字典将保存到该目录。
max_shard_size (int 或 str, 可选, 默认为 "500MB") — 上传到 hub 的数据集分片的最大大小。如果表示为字符串，则需要是数字后跟单位（例如 "50MB"）。
num_shards (Dict[str, int], 可选) — 要写入的分片数量。默认情况下，分片数量取决于 max_shard_size 和 num_proc。您需要为数据集字典中的每个数据集提供分片数量。使用字典为每个拆分定义不同的 num_shards。

在 2.8.0 版本中添加

num_proc (int, 可选, 默认为 None) — 本地下载和生成数据集时使用的进程数。默认情况下禁用多进程处理。

在 2.8.0 版本中添加

storage_options (dict, 可选) — 要传递给文件系统后端（如果有）的键/值对。

在 2.8.0 版本中添加

使用 fsspec.spec.AbstractFileSystem 将数据集字典保存到文件系统。

对于 Image 和 Audio 数据

所有 Image() 和 Audio() 数据都存储在 arrow 文件中。如果要存储路径或 URL，请使用 Value(“string”) 类型。

示例

>>> dataset_dict.save_to_disk("path/to/dataset/directory") >>> dataset_dict.save_to_disk("path/to/dataset/directory", max_shard_size="1GB") >>> dataset_dict.save_to_disk("path/to/dataset/directory", num_shards={"train": 1024, "test": 8})

load_from_disk
< source >
( dataset_dict_path: Union keep_in_memory: Optional = None storage_options: Optional = None )

参数

dataset_dict_path (path-like) — 数据集字典目录的路径（例如 "dataset/train"）或远程 URI（例如 "s3//my-bucket/dataset/train"），数据集字典将从该目录加载。
keep_in_memory (bool, 默认为 None) — 是否将数据集复制到内存中。如果为 None，则除非通过将 datasets.config.IN_MEMORY_MAX_SIZE 设置为非零值显式启用，否则数据集不会复制到内存中。有关更多详细信息，请参阅提高性能部分。
storage_options (dict, 可选) — 要传递给文件系统后端（如果有）的键/值对。

在 2.8.0 版本中添加

从文件系统加载先前使用 save_to_disk 保存的数据集，使用 fsspec.spec.AbstractFileSystem。

示例

>>> ds = load_from_disk('path/to/dataset/directory')

版本
 < source >
( path_or_paths: Dict features: Optional = None cache_dir: str = None keep_in_memory: bool = False **kwargs )

参数

path_or_paths (dict of path-like) — CSV 文件的路径。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
**kwargs (附加关键字参数) — 要传递给 pandas.read_csv 的关键字参数。

从 CSV 文件创建 DatasetDict。

示例

>>> from datasets import DatasetDict >>> ds = DatasetDict.from_csv({'train': 'path/to/dataset.csv'})

from_json
< source >
( path_or_paths: Dict features: Optional = None cache_dir: str = None keep_in_memory: bool = False **kwargs )

参数

path_or_paths (path-like 或 list of path-like) — JSON Lines 文件的路径。
features (Features, 可选) — 数据集特征。
cache_dir (str, 可选, 默认为 "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, 默认为 False) — 是否将数据复制到内存中。
**kwargs (附加关键字参数) — 要传递给 JsonConfig 的关键字参数。

创建 DatasetDict 从 JSON Lines 文件。

示例

>>> from datasets import DatasetDict >>> ds = DatasetDict.from_json({'train': 'path/to/dataset.json'})

from_parquet
< 源代码 >
( path_or_paths: Dict features: Optional = None cache_dir: str = None keep_in_memory: bool = False columns: Optional = None **kwargs )

参数

path_or_paths (dict of path-like) — Parquet 文件的路径。
features (Features, optional) — 数据集特征。
cache_dir (str, optional, defaults to "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, defaults to False) — 是否将数据复制到内存中。
columns (List[str], optional) — 如果不是 None，则仅从文件中读取这些列。列名可以是嵌套字段的前缀，例如 ‘a’ 将选择 ‘a.b’、‘a.c’ 和 ‘a.d.e’。
**kwargs (附加关键字参数) — 要传递给 ParquetConfig 的关键字参数。

创建 DatasetDict 从 Parquet 文件。

示例

>>> from datasets import DatasetDict >>> ds = DatasetDict.from_parquet({'train': 'path/to/dataset/parquet'})

from_text
< 源代码 >
( path_or_paths: Dict features: Optional = None cache_dir: str = None keep_in_memory: bool = False **kwargs )

参数

path_or_paths (dict of path-like) — 文本文件的路径。
features (Features, optional) — 数据集特征。
cache_dir (str, optional, defaults to "~/.cache/huggingface/datasets") — 用于缓存数据的目录。
keep_in_memory (bool, defaults to False) — 是否将数据复制到内存中。
**kwargs (附加关键字参数) — 要传递给 TextConfig 的关键字参数。

创建 DatasetDict 从文本文件。

示例

>>> from datasets import DatasetDict >>> ds = DatasetDict.from_text({'train': 'path/to/dataset.txt'})

IterableDataset

基类 IterableDataset 实现了一个由 Python 生成器支持的可迭代数据集。

class datasets.IterableDataset
< 源代码 >
( ex_iterable: _BaseExamplesIterable info: Optional = None split: Optional = None formatting: Optional = None shuffling: Optional = None distributed: Optional = None token_per_repo_id: Optional = None )

一个由可迭代对象支持的数据集。

from_generator
< 源代码 >
( generator: Callable features: Optional = None gen_kwargs: Optional = None split: NamedSplit = NamedSplit('train') ) → IterableDataset

参数

generator (Callable) — 一个生成器函数，用于 yield 示例。
features (Features, optional) — 数据集特征。
gen_kwargs(dict, optional) — 要传递给 `generator` 可调用对象的关键字参数。您可以通过在 `gen_kwargs` 中传递分片列表来定义分片的可迭代数据集。这可以用于改进洗牌（shuffling）以及在使用多个 worker 迭代数据集时。
split (NamedSplit, defaults to Split.TRAIN) — 要分配给数据集的拆分名称。

在 2.21.0 版本中添加

返回值

IterableDataset

从生成器创建一个可迭代数据集。

示例

>>> def gen(): ... yield {"text": "Good", "label": 0} ... yield {"text": "Bad", "label": 1} ... >>> ds = IterableDataset.from_generator(gen)

>>> def gen(shards): ... for shard in shards: ... with open(shard) as f: ... for line in f: ... yield {"line": line} ... >>> shards = [f"data{i}.txt" for i in range(32)] >>> ds = IterableDataset.from_generator(gen, gen_kwargs={"shards": shards}) >>> ds = ds.shuffle(seed=42, buffer_size=10_000) # shuffles the shards order + uses a shuffle buffer >>> from torch.utils.data import DataLoader >>> dataloader = DataLoader(ds.with_format("torch"), num_workers=4) # give each worker a subset of 32/4=8 shards

remove_columns
< 源代码 >
( column_names: Union ) → IterableDataset

参数

column_names (Union[str, List[str]]) — 要移除的列的名称。

返回值

IterableDataset

不包含要删除的列的数据集对象的副本。

移除数据集中的一个或多个列以及与其关联的特征。移除操作是在迭代数据集中的示例时即时完成的。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.remove_columns("label") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}

select_columns
< 源代码 >
( column_names: Union ) → IterableDataset

参数

column_names (Union[str, List[str]]) — 要选择的列的名称。

返回值

IterableDataset

包含选定列的数据集对象的副本。

选择数据集中的一个或多个列以及与其关联的特征。选择操作是在迭代数据集中的示例时即时完成的。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'label': 1} >>> ds = ds.select_columns("text") >>> next(iter(ds)) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}

cast_column
< 源代码 >
( column: str feature: Union ) → IterableDataset

参数

column (str) — 列名。
feature (Feature) — 目标特征。

返回值

IterableDataset

将列转换为特征以进行解码。

示例

>>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train", streaming=True) >>> ds.features {'audio': Audio(sampling_rate=8000, mono=True, decode=True, id=None), 'english_transcription': Value(dtype='string', id=None), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill'], id=None), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN'], id=None), 'path': Value(dtype='string', id=None), 'transcription': Value(dtype='string', id=None)} >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000)) >>> ds.features {'audio': Audio(sampling_rate=16000, mono=True, decode=True, id=None), 'english_transcription': Value(dtype='string', id=None), 'intent_class': ClassLabel(num_classes=14, names=['abroad', 'address', 'app_error', 'atm_limit', 'balance', 'business_loan', 'card_issues', 'cash_deposit', 'direct_debit', 'freeze', 'high_value_payment', 'joint_account', 'latest_transactions', 'pay_bill'], id=None), 'lang_id': ClassLabel(num_classes=14, names=['cs-CZ', 'de-DE', 'en-AU', 'en-GB', 'en-US', 'es-ES', 'fr-FR', 'it-IT', 'ko-KR', 'nl-NL', 'pl-PL', 'pt-PT', 'ru-RU', 'zh-CN'], id=None), 'path': Value(dtype='string', id=None), 'transcription': Value(dtype='string', id=None)}

cast
< source >
( features: Features ) → IterableDataset

参数

features (Features) — 用于将数据集转换为新特征。特征中字段的名称必须与当前的列名匹配。数据类型也必须可以从一种类型转换为另一种类型。对于非平凡的转换，例如 string <-> ClassLabel，您应该使用 map() 来更新数据集。

返回值

IterableDataset

数据集的副本，其中特征已转换。

将数据集转换为一组新的特征。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> ds.features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> new_features = ds.features.copy() >>> new_features["label"] = ClassLabel(names=["bad", "good"]) >>> new_features["text"] = Value("large_string") >>> ds = ds.cast(new_features) >>> ds.features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='large_string', id=None)}

__iter__
< source >
( )

iter
< source >
( batch_size: int drop_last_batch: bool = False )

参数

batch_size (int) — 要产生的每个批次的大小。
drop_last_batch (bool, default False) — 是否应删除小于 batch_size 的最后一个批次

遍历大小为 batch_size 的批次。

map
< source >
( function: Optional = None with_indices: bool = False input_columns: Union = None batched: bool = False batch_size: Optional = 1000 drop_last_batch: bool = False remove_columns: Union = None features: Optional = None fn_kwargs: Optional = None )

参数

function (Callable, optional, defaults to None) — 当您迭代数据集时，即时应用于示例的函数。它必须具有以下签名之一：

function(example: Dict[str, Any]) -> Dict[str, Any] 如果 batched=False 且 with_indices=False

function(example: Dict[str, Any], idx: int) -> Dict[str, Any] 如果 batched=False 且 with_indices=True

function(batch: Dict[str, List]) -> Dict[str, List] 如果 batched=True 且 with_indices=False

function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List] 如果 batched=True 且 with_indices=True

对于高级用法，该函数还可以返回 pyarrow.Table。此外，如果您的函数不返回任何内容 (None)，则 map 将运行您的函数并返回未更改的数据集。如果未提供任何函数，则默认为恒等函数：lambda x: x。
with_indices (bool, defaults to False) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 def function(example, idx[, rank]): ...。
input_columns (Optional[Union[str, List[str]]], defaults to None) — 要作为位置参数传递到 function 中的列。如果为 None，则将映射到所有格式化列的字典作为单个参数传递。
batched (bool, defaults to False) — 向 function 提供一批示例。
batch_size (int, optional, defaults to 1000) — 如果 batched=True，则为每个批次提供给 function 的示例数。 batch_size <= 0 或 batch_size == None 然后将完整数据集作为单个批次提供给 function。
drop_last_batch (bool, defaults to False) — 是否应删除小于 batch_size 的最后一个批次，而不是由函数处理。
remove_columns ([List[str]], optional, defaults to None) — 在执行映射时删除所选列。列将在使用 function 的输出更新示例之前删除，即，如果 function 正在添加名称在 remove_columns 中的列，则将保留这些列。
features ([Features], optional, defaults to None) — 结果数据集的特征类型。
fn_kwargs (Dict, optional, default None) — 要传递给 function 的关键字参数。

将函数应用于可迭代数据集中的所有示例（单独或批量），并更新它们。如果您的函数返回的列已存在，则会覆盖它。该函数在迭代数据集中的示例时即时应用。

您可以使用 batched 参数指定函数是否应分批处理

如果 batched 为 False，则该函数接受 1 个示例作为输入，并且应返回 1 个示例。示例是一个字典，例如 {"text": "Hello there !"}。

如果 batched 为 True 且 batch_size 为 1，则该函数将一批 1 个示例作为输入，并且可以返回一批包含 1 个或多个示例的批次。批次是一个字典，例如，1 个示例的批次是 {“text”: [“Hello there !”]}。

如果 batched 为 True 且 batch_size 为 n > 1，则该函数将一批 n 个示例作为输入，并且可以返回一批包含 n 个示例或任意数量示例的批次。请注意，最后一个批次可能少于 n 个示例。批次是一个字典，例如，n 个示例的批次是 {"text": ["Hello there !"] * n}。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> list(ds.take(3)) [{'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'Review: the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'Review: effective but too-tepid biopic'}]

rename_column
< source >
( original_column_name: str new_column_name: str ) → IterableDataset

参数

original_column_name (str) — 要重命名的列的名称。
new_column_name (str) — 列的新名称。

返回值

IterableDataset

数据集的副本，其中一列已重命名。

重命名数据集中的一列，并将与原始列关联的特征移动到新列名下。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> next(iter(ds)) {'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'} >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds)) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}

filter
< source >
( function: Optional = None with_indices = False input_columns: Union = None batched: bool = False batch_size: Optional = 1000 fn_kwargs: Optional = None )

参数

function (Callable) — 可调用对象，具有以下签名之一：

function(example: Dict[str, Any]) -> bool 如果 with_indices=False, batched=False

function(example: Dict[str, Any], indices: int) -> bool 如果 with_indices=True, batched=False

function(example: Dict[str, List]) -> List[bool] 如果 with_indices=False, batched=True

function(example: Dict[str, List], indices: List[int]) -> List[bool] 如果 with_indices=True, batched=True

如果未提供函数，则默认为始终为 True 的函数：lambda x: True。
with_indices (bool, defaults to False) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 def function(example, idx): ...。
input_columns (str 或 List[str], 可选) — 要作为位置参数传递到 function 中的列。如果为 None，则将映射到所有格式化列的字典作为一个参数传递。
batched (bool, 默认为 False) — 向 function 提供一批示例。
batch_size (int, 可选, 默认值 1000) — 如果 batched=True，则提供给 function 的每个批次的示例数。
fn_kwargs (Dict, 可选, 默认值 None) — 要传递给 function 的关键字参数。

对所有元素应用过滤器函数，以便数据集仅包含符合过滤器函数的示例。过滤在迭代数据集时即时完成。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds.take(3)) [{'label': 0, 'movie_review': 'simplistic , silly and tedious .'}, {'label': 0, 'movie_review': "it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'movie_review': 'exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}]

shuffle
< source >
( seed = None generator: Optional = None buffer_size: int = 1000 )

参数

seed (int, 可选, 默认为 None) — 用于打乱数据集的随机种子。它用于从打乱缓冲区中采样，以及打乱数据分片。
generator (numpy.random.Generator, 可选) — 用于计算数据集行排列的 Numpy 随机 Generator。如果 generator=None (默认)，则使用 np.random.default_rng (NumPy 的默认 BitGenerator (PCG64))。
buffer_size (int, 默认为 1000) — 缓冲区的大小。

随机打乱此数据集中的元素。

此数据集用 buffer_size 个元素填充缓冲区，然后从此缓冲区中随机抽取元素，并将选定的元素替换为新元素。为了实现完美打乱，需要缓冲区大小大于或等于数据集的完整大小。

例如，如果您的数据集包含 10,000 个元素，但 buffer_size 设置为 1000，则 shuffle 最初将仅从缓冲区中的前 1000 个元素中选择一个随机元素。一旦选择了元素，它在缓冲区中的空间将被下一个（即第 1,001 个）元素替换，从而保持 1000 个元素的缓冲区。

如果数据集由多个分片组成，它还会打乱分片的顺序。但是，如果使用 skip() 或 take() 固定了顺序，则分片的顺序将保持不变。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> shuffled_ds = ds.shuffle(seed=42) >>> list(shuffled_ds.take(3)) [{'label': 1, 'text': "a sports movie with action that's exciting on the field and a story you care about off it ."}, {'label': 1, 'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .'}, {'label': 1, 'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune ."}]

batch
< source >
( batch_size: int drop_last_batch: bool = False )

参数

batch_size (int) — 每个批次中的样本数。
drop_last_batch (bool, 默认为 False) — 是否删除最后一个不完整的批次。

将数据集中的样本分组为批次。

示例

>>> ds = load_dataset("some_dataset", streaming=True) >>> batched_ds = ds.batch(batch_size=32)

跳过
< source >
( n: int )

参数

n (int) — 要跳过的元素数量。

创建一个新的 IterableDataset，它跳过前 n 个元素。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> list(ds.take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.skip(1) >>> list(ds.take(3)) [{'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}, {'label': 1, 'text': 'if you sometimes like to go to the movies to have fun , wasabi is a good place to start .'}]

选取
< source >
( n: int )

参数

n (int) — 要获取的元素数量。

创建一个新的 IterableDataset，其中仅包含前 n 个元素。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train", streaming=True) >>> small_ds = ds.take(2) >>> list(small_ds) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}]

load_state_dict
< source >
( state_dict: dict )

加载数据集的 state_dict。迭代将从保存状态时的下一个示例重新开始。

恢复会返回到检查点保存的确切位置，但以下两种情况除外

从打乱缓冲区中恢复时，示例会丢失，并且缓冲区会用新数据重新填充

.with_format(arrow) 和批量 .map() 的组合可能会跳过一个批次。

示例

>>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example)

返回结果为

{'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5}

>>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood

state_dict
< source >
( ) → dict

返回值

dict

获取数据集的当前 state_dict。它对应于它产生的最新示例的状态。

恢复会返回到检查点保存的确切位置，但以下两种情况除外

从打乱缓冲区中恢复时，示例会丢失，并且缓冲区会用新数据重新填充

.with_format(arrow) 和批量 .map() 的组合可能会跳过一个批次。

示例

>>> from datasets import Dataset, concatenate_datasets >>> ds = Dataset.from_dict({"a": range(6)}).to_iterable_dataset(num_shards=3) >>> for idx, example in enumerate(ds): ... print(example) ... if idx == 2: ... state_dict = ds.state_dict() ... print("checkpoint") ... break >>> ds.load_state_dict(state_dict) >>> print(f"restart from checkpoint") >>> for example in ds: ... print(example)

返回结果为

{'a': 0} {'a': 1} {'a': 2} checkpoint restart from checkpoint {'a': 3} {'a': 4} {'a': 5}

>>> from torchdata.stateful_dataloader import StatefulDataLoader >>> ds = load_dataset("deepmind/code_contests", streaming=True, split="train") >>> dataloader = StatefulDataLoader(ds, batch_size=32, num_workers=4) >>> # checkpoint >>> state_dict = dataloader.state_dict() # uses ds.state_dict() under the hood >>> # resume from checkpoint >>> dataloader.load_state_dict(state_dict) # uses ds.load_state_dict() under the hood

info
< source >
( )

DatasetInfo 对象，包含数据集中所有元数据。

split
< source >
( )

NamedSplit 对象，对应于命名数据集拆分。

builder_name
< source >
( )

citation
< source >
( )

config_name
< source >
( )

dataset_size
< source >
( )

description
< source >
( )

描述
< source >
( )

download_checksums
< source >
( )

download_size
< source >
( )

特征
< source >
( )

主页
license
( )

许可证
size_in_bytes
( )

字节大小
 < source >
( )

监督键
 < source >
( )

IterableDatasetDict

字典，其中 split 名称作为键（例如 ‘train’、‘test’），IterableDataset 对象作为值。

class datasets.IterableDatasetDict
< source >
( )

map
< source >
( function: Optional = None with_indices: bool = False input_columns: Union = None batched: bool = False batch_size: int = 1000 drop_last_batch: bool = False remove_columns: Union = None fn_kwargs: Optional = None )

参数

function (Callable，可选，默认为 None) — 当您迭代数据集时，即时应用于示例的函数。它必须具有以下签名之一：

function(example: Dict[str, Any]) -> Dict[str, Any] if batched=False and with_indices=False

function(example: Dict[str, Any], idx: int) -> Dict[str, Any] if batched=False and with_indices=True

function(batch: Dict[str, List]) -> Dict[str, List] if batched=True and with_indices=False

function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List] if batched=True and with_indices=True

对于高级用法，该函数还可以返回 pyarrow.Table。此外，如果您的函数没有返回任何内容 (None)，则 map 将运行您的函数并返回未更改的数据集。如果没有提供函数，则默认为恒等函数：lambda x: x。
with_indices (bool，默认为 False) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 def function(example, idx[, rank]): ...。
input_columns ([Union[str, List[str]]]，可选，默认为 None) — 要作为位置参数传递到 function 中的列。如果为 None，则会将映射到所有格式化列的字典作为单个参数传递。
batched (bool，默认为 False) — 向 function 提供示例批次。
batch_size (int，可选，默认为 1000) — 如果 batched=True，则提供给 function 的每个批次的示例数。
drop_last_batch (bool，默认为 False) — 是否应丢弃小于 batch_size 的最后一个批次，而不是由函数处理。
remove_columns ([List[str]]，可选，默认为 None) — 在执行映射时删除选定的列。列将在使用 function 的输出更新示例之前删除，即，如果 function 正在添加名称在 remove_columns 中的列，则这些列将保留。
fn_kwargs (Dict，可选，默认为 None) — 要传递给 function 的关键字参数

将函数应用于可迭代数据集中的所有示例（单独或批量），并更新它们。如果您的函数返回的列已存在，则它会覆盖它。该函数在迭代数据集中的示例时即时应用。转换应用于数据集字典的所有数据集。

您可以使用 batched 参数指定函数是否应分批处理

如果 batched 为 False，则该函数接受 1 个示例作为输入，并且应返回 1 个示例。示例是一个字典，例如 {"text": "Hello there !"}。

如果 batched 为 True 且 batch_size 为 1，则该函数接受 1 个示例的批次作为输入，并且可以返回包含 1 个或多个示例的批次。批次是一个字典，例如，1 个示例的批次是 {"text": ["Hello there !"]}。

如果 batched 为 True 且 batch_size 为 n > 1，则该函数将一批 n 个示例作为输入，并且可以返回一批包含 n 个示例或任意数量示例的批次。请注意，最后一个批次可能少于 n 个示例。批次是一个字典，例如，n 个示例的批次是 {"text": ["Hello there !"] * n}。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> def add_prefix(example): ... example["text"] = "Review: " + example["text"] ... return example >>> ds = ds.map(add_prefix) >>> next(iter(ds["train"])) {'label': 1, 'text': 'Review: the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}

filter
< source >
( function: Optional = None with_indices = False input_columns: Union = None batched: bool = False batch_size: Optional = 1000 fn_kwargs: Optional = None )

参数

function (Callable) — 具有以下签名之一的可调用对象：

function(example: Dict[str, Any]) -> bool if with_indices=False, batched=False

function(example: Dict[str, Any], indices: int) -> bool if with_indices=True, batched=False

function(example: Dict[str, List]) -> List[bool] if with_indices=False, batched=True

function(example: Dict[str, List], indices: List[int]) -> List[bool] if with_indices=True, batched=True

如果没有提供函数，则默认为始终为 True 的函数：lambda x: True。
with_indices (bool，默认为 False) — 向 function 提供示例索引。请注意，在这种情况下，function 的签名应为 def function(example, idx): ...。
input_columns (str 或 List[str]，可选) — 要作为位置参数传递到 function 中的列。如果为 None，则会将映射到所有格式化列的字典作为单个参数传递。
batched (bool，默认为 False) — 向 function 提供示例批次
batch_size (int，可选，默认为 1000) — 如果 batched=True，则提供给 function 的每个批次的示例数。
fn_kwargs (Dict，可选，默认为 None) — 要传递给 function 的关键字参数

将筛选函数应用于所有元素，以便数据集仅包含符合筛选函数的示例。筛选在迭代数据集时即时完成。筛选应用于数据集字典的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds = ds.filter(lambda x: x["label"] == 0) >>> list(ds["train"].take(3)) [{'label': 0, 'text': 'Review: simplistic , silly and tedious .'}, {'label': 0, 'text': "Review: it's so laddish and juvenile , only teenage boys could possibly find it funny ."}, {'label': 0, 'text': 'Review: exploitative and largely devoid of the depth or sophistication that would make watching such a graphic treatment of the crimes bearable .'}]

shuffle
< source >
( seed = None generator: Optional = None buffer_size: int = 1000 )

参数

seed (int，可选，默认为 None) — 将用于洗牌数据集的随机种子。它用于从洗牌缓冲区中采样，并用于洗牌数据分片。
generator (numpy.random.Generator，可选) — 用于计算数据集行排列的 Numpy 随机生成器。如果 generator=None（默认），则使用 np.random.default_rng（NumPy 的默认 BitGenerator (PCG64)）。
buffer_size (int，默认为 1000) — 缓冲区的大小。

随机洗牌此数据集的元素。洗牌应用于数据集字典的所有数据集。

此数据集用 buffer_size 个元素填充缓冲区，然后从此缓冲区中随机抽取元素，并将选定的元素替换为新元素。为了实现完美的洗牌，需要缓冲区大小大于或等于数据集的完整大小。

例如，如果您的数据集包含 10,000 个元素，但 buffer_size 设置为 1000，则 shuffle 最初将仅从缓冲区中的前 1000 个元素中选择一个随机元素。一旦选择了元素，它在缓冲区中的空间将被下一个（即第 1,001 个）元素替换，从而保持 1000 个元素的缓冲区。

如果数据集由多个分片组成，它也会洗牌分片的顺序。但是，如果顺序已通过使用 skip() 或 take() 固定，则分片的顺序保持不变。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> list(ds["train"].take(3)) [{'label': 1, 'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}, {'label': 1, 'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .'}, {'label': 1, 'text': 'effective but too-tepid biopic'}] >>> ds = ds.shuffle(seed=42) >>> list(ds["train"].take(3)) [{'label': 1, 'text': "a sports movie with action that's exciting on the field and a story you care about off it ."}, {'label': 1, 'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .'}, {'label': 1, 'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune ."}]

with_format
< source >
( type: Optional = None )

参数

type (str, 可选, 默认为 None) — 如果设置为 “torch”，则返回的数据集将是 torch.utils.data.IterableDataset 的子类，以便在 DataLoader 中使用。

返回指定格式的数据集。此方法目前仅支持 “torch” 格式。格式将应用于数据集字典中的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased") >>> def encode(example): ... return tokenizer(examples["text"], truncation=True, padding="max_length") >>> ds = ds.map(encode, batched=True, remove_columns=["text"]) >>> ds = ds.with_format("torch")

cast
< source >
( features: Features ) → IterableDatasetDict

参数

features (Features) — 用于转换数据集的新 features。 features 中字段的名称必须与当前的列名匹配。数据类型也必须可以相互转换。对于非平凡的转换，例如 string <-> ClassLabel，您应该使用 map 来更新 Dataset。

返回值

IterableDatasetDict

数据集的副本，其中特征已转换。

将数据集转换为一组新的 features。类型转换应用于数据集字典中的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> new_features = ds["train"].features.copy() >>> new_features['label'] = ClassLabel(names=['bad', 'good']) >>> new_features['text'] = Value('large_string') >>> ds = ds.cast(new_features) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='large_string', id=None)}

cast_column
< source >
( column: str feature: Union )

参数

column (str) — 列名。
feature (Feature) — 目标 feature。

将列转换为 feature 以进行解码。类型转换应用于数据集字典中的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)} >>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good'])) >>> ds["train"].features {'label': ClassLabel(num_classes=2, names=['bad', 'good'], id=None), 'text': Value(dtype='string', id=None)}

remove_columns
< source >
( column_names: Union ) → IterableDatasetDict

参数

column_names (Union[str, List[str]]) — 要移除的列名。

返回值

IterableDatasetDict

不包含要删除的列的数据集对象的副本。

移除数据集中的一列或多列以及与其关联的 features。移除操作在迭代数据集中的示例时即时完成。移除操作应用于数据集字典中的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds = ds.remove_columns("label") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}

rename_column
< source >
( original_column_name: str new_column_name: str ) → IterableDatasetDict

参数

original_column_name (str) — 要重命名的列的名称。
new_column_name (str) — 列的新名称。

返回值

IterableDatasetDict

数据集的副本，其中一列已重命名。

重命名数据集中的列，并将与原始列关联的 features 移动到新列名下。重命名操作应用于数据集字典中的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds = ds.rename_column("text", "movie_review") >>> next(iter(ds["train"])) {'label': 1, 'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}

rename_columns
< source >
( column_mapping: Dict ) → IterableDatasetDict

参数

column_mapping (Dict[str, str]) — 将要重命名的列映射到其新名称的字典。

返回值

IterableDatasetDict

数据集的副本，其中列已重命名

重命名数据集中的多个列，并将与原始列关联的 features 移动到新列名下。重命名操作应用于数据集字典中的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds = ds.rename_columns({"text": "movie_review", "label": "rating"}) >>> next(iter(ds["train"])) {'movie_review': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .', 'rating': 1}

select_columns
< source >
( column_names: Union ) → IterableDatasetDict

参数

column_names (Union[str, List[str]]) — 要保留的列名。

返回值

IterableDatasetDict

数据集对象的副本，仅包含选定的列。

选择数据集中的一列或多列以及与其关联的 features。选择操作在迭代数据集中的示例时即时完成。选择操作应用于数据集字典中的所有数据集。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", streaming=True) >>> ds = ds.select("text") >>> next(iter(ds["train"])) {'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .'}

Features

class datasets.Features
< source >
( *args **kwargs )

一个特殊的字典，用于定义数据集的内部结构。

使用 dict[str, FieldType] 类型的字典实例化，其中键是所需的列名，值是该列的类型。

FieldType 可以是以下类型之一

Value feature 指定一个单一数据类型的值，例如 int64 或 string。

ClassLabel feature 指定一组预定义的类，这些类可以具有与之关联的标签，并将作为整数存储在数据集中。

Python dict 指定一个复合 feature，其中包含子字段到子 features 的映射。可以任意嵌套字段的字段。

Python list、LargeList 或 Sequence 指定一个复合 feature，其中包含一系列子 features，所有子 features 都具有相同的 feature 类型。

具有内部字典 feature 的 Sequence 将自动转换为列表字典。此行为的实现是为了与 TensorFlow Datasets 库具有兼容层，但在某些情况下可能不需要。如果您不想要此行为，可以使用 Python list 或 LargeList 而不是 Sequence。

Array2D, Array3D, Array4D 或 Array5D feature 用于多维数组。

Audio feature 用于存储音频文件的绝对路径，或包含音频文件的相对路径（“path” 键）及其字节内容（“bytes” 键）的字典。此 feature 提取音频数据。

Image feature 用于存储图像文件的绝对路径、np.ndarray 对象、PIL.Image.Image 对象或包含图像文件的相对路径（“path” 键）及其字节内容（“bytes” 键）的字典。此 feature 提取图像数据。

Translation 或 TranslationVariableLanguages feature 专用于机器翻译。

copy
< source >
( )

对 Features 进行深度复制。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train") >>> copy_of_features = ds.features.copy() >>> copy_of_features {'label': ClassLabel(num_classes=2, names=['neg', 'pos'], id=None), 'text': Value(dtype='string', id=None)}

decode_batch
< source >
( batch: dict token_per_repo_id: Optional = None )

参数

batch (dict[str, list[Any]]) — 数据集批次数据。
token_per_repo_id (dict, 可选) — 要访问和解码来自 Hub 上私有仓库的音频或图像文件，您可以传递一个字典 repo_id (str) -> token (bool 或 str)

使用自定义 feature 解码来解码批次。

decode_column
< source >
( column: list column_name: str )

参数

column (list[Any]) — 数据集列数据。
column_name (str) — Dataset column name.

使用自定义特征解码来解码列。

decode_example
< source >
( example: dict token_per_repo_id: Optional = None )

参数

example (dict[str, Any]) — Dataset row data.
token_per_repo_id (dict, optional) — To access and decode audio or image files from private repositories on the Hub, you can pass a dictionary repo_id (str) -> token (bool or str).

使用自定义特征解码来解码示例。

encode_batch
< source >
( batch )

参数

batch (dict[str, list[Any]]) — Data in a Dataset batch.

将批次编码为 Arrow 格式。

encode_column
< source >
( column column_name: str )

参数

column (list[Any]) — Data in a Dataset column.
column_name (str) — Dataset column name.

将列编码为 Arrow 格式。

encode_example
< source >
( example )

参数

example (dict[str, Any]) — Data in a Dataset row.

将示例编码为 Arrow 格式。

flatten
< source >
( max_depth = 16 ) → Features

返回值

Features

扁平化后的特征。

扁平化特征。每个字典列都会被移除，并被它包含的所有子字段替换。新字段通过连接原始列的名称和子字段名称来命名，格式如下：<original>.<subfield>。

如果列包含嵌套字典，则所有更低级别的子字段名称也会被连接起来以形成新列：<original>.<subfield>.<subsubfield>，等等。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("squad", split="train") >>> ds.features.flatten() {'answers.answer_start': Sequence(feature=Value(dtype='int32', id=None), length=-1, id=None), 'answers.text': Sequence(feature=Value(dtype='string', id=None), length=-1, id=None), 'context': Value(dtype='string', id=None), 'id': Value(dtype='string', id=None), 'question': Value(dtype='string', id=None), 'title': Value(dtype='string', id=None)}

from_arrow_schema
< source >
( pa_schema: Schema )

参数

pa_schema (pyarrow.Schema) — Arrow Schema.

从 Arrow Schema 构建 Features。它还会检查模式元数据中是否有 Hugging Face Datasets 特征。不支持非空字段，并将其设置为可为空。

此外，不支持 pa.dictionary，而是使用其底层类型。因此，数据集会将 DictionaryArray 对象转换为它们的实际值。

from_dict
< source >
( dic ) → Features

参数

dic (dict[str, Any]) — Python dictionary.

返回值

Features

从字典构建 [Features]。

从反序列化的字典中重新生成嵌套的特征对象。我们使用 _type 键来推断特征 FieldType 的数据类名称。

它允许使用方便的构造函数语法从反序列化的 JSON 字典中定义特征。此函数尤其在反序列化转储到 JSON 对象的 [DatasetInfo] 时使用。这类似于 [Features.from_arrow_schema]，并处理递归的字段实例化，但不需要任何到/从 pyarrow 的映射，除了 [Value] 自动执行的 pyarrow 原始数据类型映射之外。

示例

>>> Features.from_dict({'_type': {'dtype': 'string', 'id': None, '_type': 'Value'}}) {'_type': Value(dtype='string', id=None)}

reorder_fields_as
< source >
( other: Features )

参数

other ([Features]) — The other [Features] to align with.

重新排序 Features 字段以匹配其他 [Features] 的字段顺序。

字段的顺序很重要，因为它关系到底层的 arrow 数据。重新排序字段可以使底层的 arrow 数据类型匹配。

示例

>>> from datasets import Features, Sequence, Value >>> # let's say we have two features with a different order of nested fields (for a and b for example) >>> f1 = Features({"root": Sequence({"a": Value("string"), "b": Value("string")})}) >>> f2 = Features({"root": {"b": Sequence(Value("string")), "a": Sequence(Value("string"))}}) >>> assert f1.type != f2.type >>> # re-ordering keeps the base structure (here Sequence is defined at the root level), but makes the fields order match >>> f1.reorder_fields_as(f2) {'root': Sequence(feature={'b': Value(dtype='string', id=None), 'a': Value(dtype='string', id=None)}, length=-1, id=None)} >>> assert f1.reorder_fields_as(f2).type == f2.type

标量

class datasets.Value
< source >
( dtype: str id: Optional = None )

参数

dtype (str) — Name of the data type.

特定数据类型的标量特征值。

Value 可能的数据类型如下：

null

bool

int8

int16

int32

int64

uint8

uint16

uint32

uint64

float16

float32 (别名 float)

float64 (别名 double)

time32[(s|ms)]

time64[(us|ns)]

timestamp[(s|ms|us|ns)]

timestamp[(s|ms|us|ns), tz=(tzstring)]

date32

date64

duration[(s|ms|us|ns)]

decimal128(precision, scale)

decimal256(precision, scale)

binary

large_binary

string

large_string

示例

>>> from datasets import Features >>> features = Features({'stars': Value(dtype='int32')}) >>> features {'stars': Value(dtype='int32', id=None)}

class datasets.ClassLabel
< source >
( num_classes: dataclasses.InitVar[typing.Optional[int]] = None names: List = None names_file: dataclasses.InitVar[typing.Optional[str]] = None id: Optional = None )

参数

num_classes (int, optional) — Number of classes. All labels must be < num_classes.
names (list of str, optional) — String names for the integer classes. The order in which the names are provided is kept.
names_file (str, optional) — Path to a file with names for the integer classes, one per line.

整数类标签的特征类型。

定义 ClassLabel 有 3 种方式，对应于 3 个参数：

num_classes: 创建 0 到 (num_classes-1) 的标签。

names: 标签字符串列表。

names_file: 包含标签列表的文件。

在底层，标签存储为整数。您可以使用负整数来表示未知/缺失的标签。

示例

>>> from datasets import Features >>> features = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])}) >>> features {'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'], id=None)}

cast_storage
< source >
( storage: Union ) → pa.Int64Array

参数

storage (Union[pa.StringArray, pa.IntegerArray]) — PyArrow 数组以进行转换。

返回值

pa.Int64Array

ClassLabel arrow 存储类型中的数组。

将 Arrow 数组转换为 ClassLabel arrow 存储类型。可以转换为 ClassLabel pyarrow 存储类型的 Arrow 类型包括

pa.string()

pa.int()

int2str
< source >
( values: Union )

转换 integer => 类名 string。

关于未知/缺失标签：传递负整数会引发 ValueError。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train") >>> ds.features["label"].int2str(0) 'neg'

str2int
< source >
( values: Union )

转换类名 string => integer。

示例

>>> from datasets import load_dataset >>> ds = load_dataset("rotten_tomatoes", split="train") >>> ds.features["label"].str2int('neg') 0

复合类型

class datasets.LargeList
< source >
( feature: Any id: Optional = None )

参数

feature (FeatureType) — 大型列表中每个项目的子特征数据类型。

由子特征数据类型组成的大型列表数据的特征类型。

它由 pyarrow.LargeListType 支持，这类似于 pyarrow.ListType，但使用 64 位偏移量而不是 32 位。

class datasets.Sequence
< source >
( feature: Any length: int = -1 id: Optional = None )

参数

feature (FeatureType) — 单一类型特征列表或类型字典。
length (int) — 序列的长度。

从单一类型或类型字典构建特征列表。主要用于与 tfds 兼容。

示例

>>> from datasets import Features, Sequence, Value, ClassLabel >>> features = Features({'post': Sequence(feature={'text': Value(dtype='string'), 'upvotes': Value(dtype='int32'), 'label': ClassLabel(num_classes=2, names=['hot', 'cold'])})}) >>> features {'post': Sequence(feature={'text': Value(dtype='string', id=None), 'upvotes': Value(dtype='int32', id=None), 'label': ClassLabel(num_classes=2, names=['hot', 'cold'], id=None)}, length=-1, id=None)}

Translation

class datasets.Translation
< source >
( languages: List id: Optional = None )

参数

languages (dict) — 每个示例的字典，将字符串语言代码映射到字符串翻译。

每个示例具有固定语言的 Feature。此处用于与 tfds 兼容。

示例

>>> # At construction time: >>> datasets.features.Translation(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': 'le chat', ... 'de': 'die katze' ... }

flatten
< source >
( )

将 Translation 特征展平为字典。

class datasets.TranslationVariableLanguages
< source >
( languages: Optional = None num_languages: Optional = None id: Optional = None ) →

language 或 translation (可变长度 1D tf.Tensor of tf.string)

参数

languages (dict) — 每个示例的字典，将字符串语言代码映射到一个或多个字符串翻译。存在的语言可能因示例而异。

返回值

language 或 translation (可变长度 1D tf.Tensor of tf.string)

按升序排列的语言代码或纯文本翻译，排序以与语言代码对齐。

每个示例具有可变语言的 Feature。此处用于与 tfds 兼容。

示例

>>> # At construction time: >>> datasets.features.TranslationVariableLanguages(languages=['en', 'fr', 'de']) >>> # During data generation: >>> yield { ... 'en': 'the cat', ... 'fr': ['le chat', 'la chatte,'] ... 'de': 'die katze' ... } >>> # Tensor returned : >>> { ... 'language': ['en', 'de', 'fr', 'fr'], ... 'translation': ['the cat', 'die katze', 'la chatte', 'le chat'], ... }

flatten
< source >
( )

将 TranslationVariableLanguages 特征展平为字典。

数组

class datasets.Array2D
< source >
( shape: tuple dtype: str id: Optional = None )

参数

shape (tuple) — 每个维度的大小。
dtype (str) — 数据类型的名称。

创建一个二维数组。

示例

>>> from datasets import Features >>> features = Features({'x': Array2D(shape=(1, 3), dtype='int32')})

class datasets.Array3D
< source >
( shape: tuple dtype: str id: Optional = None )

参数

shape (tuple) — 每个维度的大小。
dtype (str) — 数据类型的名称。

创建一个三维数组。

示例

>>> from datasets import Features >>> features = Features({'x': Array3D(shape=(1, 2, 3), dtype='int32')})

class datasets.Array4D
< source >
( shape: tuple dtype: str id: Optional = None )

参数

shape (tuple) — 每个维度的大小。
dtype (str) — 数据类型的名称。

创建一个四维数组。

示例

>>> from datasets import Features >>> features = Features({'x': Array4D(shape=(1, 2, 2, 3), dtype='int32')})

class datasets.Array5D
< source >
( shape: tuple dtype: str id: Optional = None )

参数

shape (tuple) — 每个维度的大小。
dtype (str) — 数据类型的名称。

创建一个五维数组。

示例

>>> from datasets import Features >>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')})

音频

class datasets.Audio
< source >
( sampling_rate: Optional = None mono: bool = True decode: bool = True id: Optional = None )

参数

sampling_rate (int, optional) — 目标采样率。如果为 None，则使用原始采样率。
mono (bool, defaults to True) — 是否通过平均各通道的样本将音频信号转换为单声道。
decode (bool, defaults to True) — 是否解码音频数据。如果为 False，则返回格式为 {"path": audio_path, "bytes": audio_bytes} 的底层字典。

Audio Feature 用于从音频文件中提取音频数据。

输入：Audio 特征接受以下输入

一个 str：音频文件的绝对路径（即允许随机访问）。

一个 dict，包含以下键：

path：字符串，表示音频文件相对于归档文件的相对路径。

bytes：音频文件的字节内容。

这对于具有顺序访问权限的归档文件很有用。

一个 dict，包含以下键：

path：字符串，表示音频文件相对于归档文件的相对路径。

array：包含音频样本的数组

sampling_rate：整数，对应于音频样本的采样率。

这对于具有顺序访问权限的归档文件很有用。

示例

>>> from datasets import load_dataset, Audio >>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train") >>> ds = ds.cast_column("audio", Audio(sampling_rate=16000)) >>> ds[0]["audio"] {'array': array([ 2.3443763e-05, 2.1729663e-04, 2.2145823e-04, ..., 3.8356509e-05, -7.3497440e-06, -2.1754686e-05], dtype=float32), 'path': '/root/.cache/huggingface/datasets/downloads/extracted/f14948e0e84be638dd7943ac36518a4cf3324e8b7aa331c5ab11541518e9368c/en-US~JOINT_ACCOUNT/602ba55abb1e6d0fbce92065.wav', 'sampling_rate': 16000}

cast_storage
< source >
( storage: Union ) → pa.StructArray

参数

storage (Union[pa.StringArray, pa.StructArray]) — 要转换的 PyArrow 数组。

返回值

pa.StructArray

Audio arrow 存储类型中的数组，即 pa.struct({"bytes": pa.binary(), "path": pa.string()})

将 Arrow 数组转换为 Audio arrow 存储类型。可以转换为 Audio pyarrow 存储类型的 Arrow 类型有

pa.string() - 它必须包含 “path” 数据

pa.binary() - 它必须包含音频字节

pa.struct({"bytes": pa.binary()})

pa.struct({"path": pa.string()})

pa.struct({"bytes": pa.binary(), "path": pa.string()}) - 顺序无关紧要

decode_example
< source >
( value: dict token_per_repo_id: Optional = None ) → dict

参数

value (dict) — 具有以下键的字典：

path：字符串，表示音频文件的相对路径。

bytes：音频文件的字节。

token_per_repo_id (dict, optional) — 为了访问和解码来自 Hub 上私有仓库的音频文件，您可以传递一个字典 repo_id (str) -> token (bool 或 str)

返回值

dict

将示例音频文件解码为音频数据。

embed_storage
< source >
( storage: StructArray ) → pa.StructArray

参数

storage (pa.StructArray) — 要嵌入的 PyArrow 数组。

返回值

pa.StructArray

Audio arrow 存储类型中的数组，即 pa.struct({"bytes": pa.binary(), "path": pa.string()})。

将音频文件嵌入到 Arrow 数组中。

encode_example
< source >
( value: Union ) → dict

参数

value (str or dict) — 作为输入传递给 Audio 特征的数据。

返回值

dict

将示例编码为 Arrow 格式。

flatten
< source >
( )

如果在可解码状态，则引发错误，否则将特征展平为字典。

图像

class datasets.Image
< source >
( mode: Optional = None decode: bool = True id: Optional = None )

参数

mode (str, optional) — 要将图像转换为的模式。如果为 None，则使用图像的原始模式。
decode (bool, defaults to True) — 是否解码图像数据。如果为 False，则返回格式为 {"path": image_path, "bytes": image_bytes} 的底层字典。

Image Feature 用于从图像文件中读取图像数据。

输入：Image 特征接受以下输入

一个 str：图像文件的绝对路径（即允许随机访问）。

一个 dict，包含以下键：

path：字符串，表示图像文件相对于归档文件的相对路径。

bytes：图像文件的字节。

这对于具有顺序访问权限的归档文件很有用。

一个 np.ndarray：NumPy 数组，表示图像。

一个 PIL.Image.Image：PIL 图像对象。

示例

>>> from datasets import load_dataset, Image >>> ds = load_dataset("beans", split="train") >>> ds.features["image"] Image(decode=True, id=None) >>> ds[0]["image"] <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x15E52E7F0> >>> ds = ds.cast_column('image', Image(decode=False)) {'bytes': None, 'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/healthy/healthy_train.85.jpg'}

cast_storage
< source >
( storage: Union ) → pa.StructArray

参数

storage (Union[pa.StringArray, pa.StructArray, pa.ListArray]) — 要转换的 PyArrow 数组。

返回值

pa.StructArray

Image arrow 存储类型中的数组，即 pa.struct({"bytes": pa.binary(), "path": pa.string()})。

将 Arrow 数组转换为 Image arrow 存储类型。可以转换为 Image pyarrow 存储类型的 Arrow 类型有

pa.string() - 它必须包含 “path” 数据

pa.binary() - 它必须包含图像字节

pa.struct({"bytes": pa.binary()})

pa.struct({"path": pa.string()})

pa.struct({"bytes": pa.binary(), "path": pa.string()}) - 顺序无关紧要

pa.list(*) - 它必须包含图像数组数据

decode_example
< source >
( value: dict token_per_repo_id = None )

参数

value (str or dict) — 一个字符串，表示图像文件的绝对路径；或者一个字典，包含以下键：

path：字符串，表示图像文件的绝对路径或相对路径。

bytes：图像文件的字节。

token_per_repo_id (dict, optional) — 为了访问和解码来自 Hub 上私有仓库的图像文件，您可以传递一个字典 repo_id (str) -> token (bool 或 str)。

将示例图像文件解码为图像数据。

embed_storage
< source >
( storage: StructArray ) → pa.StructArray

参数

storage (pa.StructArray) — 要嵌入的 PyArrow 数组。

返回值

pa.StructArray

Image arrow 存储类型中的数组，即 pa.struct({"bytes": pa.binary(), "path": pa.string()})。

将图像文件嵌入到 Arrow 数组中。

encode_example
< 源代码 >
( value: Union )

参数

value (str, np.ndarray, PIL.Image.Image 或 dict) — 作为输入传递给 Image 特征的数据。

将示例编码为 Arrow 格式。

flatten
< 源代码 >
( )

如果在可解码状态，则返回特征本身，否则将特征扁平化为一个字典。

文件系统

datasets.filesystems.is_remote_filesystem
< 源代码 >
( fs: AbstractFileSystem )

参数

fs (fsspec.spec.AbstractFileSystem) — pythonic 文件系统的抽象超类，例如 fsspec.filesystem('file') 或 s3fs.S3FileSystem。

检查 fs 是否为远程文件系统。

指纹

class datasets.fingerprint.Hasher
< 源代码 >
( )

接受 python 对象作为输入的 Hasher。
< > 在 GitHub 上更新