Hugging Face's logo

Datasets documentation

加载

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v4.8.4).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

加载

您的数据可以存储在各种位置：本地磁盘、Github 仓库，以及 Python 字典和 Pandas DataFrame 等内存数据结构。无论数据集存储在哪里，🤗 Datasets 都能帮助您加载它。

本指南将向你展示如何从以下来源加载数据集：

  • Hugging Face Hub
  • 本地文件
  • 内存中的数据
  • 离线
  • 拆分后的特定切片

如需了解加载其他数据集模态的更多详细信息，请参阅加载音频数据集指南、加载图像数据集指南、加载视频数据集指南、加载网格数据集指南、加载文本数据集指南或加载智能体评估任务指南。

Hugging Face Hub

您还可以从 Hub 上的任何数据集仓库加载数据集！首先，创建一个数据集仓库并上传您的数据文件。现在，您可以使用 load_dataset() 函数来加载该数据集。

例如，尝试通过提供仓库命名空间和数据集名称来加载此演示仓库中的文件。该数据集仓库包含 CSV 文件，以下代码从 CSV 文件中加载数据集：

>>> from datasets import load_dataset
>>> dataset = load_dataset("lhoestq/demo1")

某些数据集可能基于 Git 标签、分支或提交拥有多个版本。使用 revision 参数来指定要加载的数据集版本：

>>> dataset = load_dataset(
...   "lhoestq/custom_squad",
...   revision="main"  # tag name, or branch name, or commit hash
... )

有关如何在 Hub 上创建数据集仓库以及如何上传数据文件的详细信息，请参阅 将数据集上传到 Hub 教程。

默认情况下，数据集会将所有数据加载到 train 拆分中，或者检查数据文件名中是否包含拆分名称（例如 “train”、“test” 和 “validation”）。使用 data_files 参数可以将数据文件映射到 train、validation 和 test 等拆分：

>>> data_files = {"train": "train.csv", "test": "test.csv"}
>>> dataset = load_dataset("namespace/your_dataset_name", data_files=data_files)

如果未指定要使用的数据文件，load_dataset() 将返回所有数据文件。如果加载像 C4 这样的大型数据集（约 13TB 数据），这可能会花费很长时间。

您还可以通过 data_files 或 data_dir 参数加载文件的特定子集。这些参数可以接受相对路径，该路径将解析为数据集加载位置对应的基准路径。

>>> from datasets import load_dataset

# load files that match the grep pattern
>>> c4_subset = load_dataset("allenai/c4", data_files="en/c4-train.0000*-of-01024.json.gz")

# load dataset from the en directory on the Hub
>>> c4_subset = load_dataset("allenai/c4", data_dir="en")

split 参数还可以将数据文件映射到特定的 split：

>>> data_files = {"validation": "en/c4-validation.*.json.gz"}
>>> c4_validation = load_dataset("allenai/c4", data_files=data_files, split="validation")

本地和远程文件

数据集可以从存储在计算机上的本地文件和远程文件加载。数据集通常以 csv、json、txt、parquet 或 tsfile 文件的形式存储。load_dataset() 函数可以加载这些文件类型中的每一种。

CSV

🤗 Datasets 可以读取由一个或多个 CSV 文件组成的数据集（在这种情况下，请将您的 CSV 文件作为列表传入）：

>>> from datasets import load_dataset
>>> dataset = load_dataset("csv", data_files="my_file.csv")

有关更多详细信息，请参阅如何从 CSV 文件加载表格数据集指南。

JSON

JSON 文件可以直接使用 load_dataset() 加载，如下所示：

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json")

JSON 文件有多种格式，但我们认为最高效的格式是包含多个 JSON 对象，其中每一行代表一条数据。例如：

{"a": 1, "b": 2.0, "c": "foo", "d": false}
{"a": 4, "b": -5.5, "c": null, "d": true}

您可能会遇到的另一种 JSON 格式是嵌套字段，此时您需要按照以下示例指定 field 参数：

{"version": "0.1.0",
 "data": [{"a": 1, "b": 2.0, "c": "foo", "d": false},
          {"a": 4, "b": -5.5, "c": null, "d": true}]
}

>>> from datasets import load_dataset
>>> dataset = load_dataset("json", data_files="my_file.json", field="data")

要通过 HTTP 加载远程 JSON 文件，请改为传入 URL：

>>> base_url = "https://rajpurkar.github.io/SQuAD-explorer/dataset/"
>>> dataset = load_dataset("json", data_files={"train": base_url + "train-v1.1.json", "validation": base_url + "dev-v1.1.json"}, field="data")

虽然这些是最常见的 JSON 格式，但您也会看到采用其他格式的数据集。🤗 Datasets 能够识别这些其他格式，并相应地回退到 Python 的 JSON 加载方法来处理它们。

Parquet

Parquet 文件以列式格式存储，这与 CSV 等基于行的文件不同。大型数据集可能会存储在 Parquet 文件中，因为其在返回查询结果时效率更高、速度更快。

要加载 Parquet 文件：

>>> from datasets import load_dataset
>>> dataset = load_dataset("parquet", data_files={'train': 'train.parquet', 'test': 'test.parquet'})

要通过 HTTP 加载远程 Parquet 文件，请改为传入 URL：

>>> base_url = "https://huggingface.co/datasets/wikimedia/wikipedia/resolve/main/20231101.ab/"
>>> data_files = {"train": base_url + "train-00000-of-00001.parquet"}
>>> wiki = load_dataset("parquet", data_files=data_files, split="train")

Arrow

与 CSV 等基于行的格式以及 Parquet 等未压缩格式不同，Arrow 文件以内存中的列式格式存储。

要加载 Arrow 文件：

>>> from datasets import load_dataset
>>> dataset = load_dataset("arrow", data_files={'train': 'train.arrow', 'test': 'test.arrow'})

要通过 HTTP 加载远程 Arrow 文件，请传入 URL：

>>> base_url = "https://huggingface.co/datasets/croissantllm/croissant_dataset/resolve/main/english_660B_11/"
>>> data_files = {"train": base_url + "train/data-00000-of-00080.arrow"}
>>> wiki = load_dataset("arrow", data_files=data_files, split="train")

Arrow is the file format used by 🤗 Datasets under the hood, therefore you can load a local Arrow file using Dataset.from_file() directly:

>>> from datasets import Dataset
>>> dataset = Dataset.from_file("data.arrow")

与 load_dataset() 不同，Dataset.from_file() 会对 Arrow 文件进行内存映射，而不会在缓存中准备数据集，从而节省磁盘空间。在这种情况下，用于存储中间处理结果的缓存目录将是该 Arrow 文件所在的目录。

目前仅支持 Arrow 流式格式。不支持 Arrow IPC 文件格式（也称为 Feather V2）。

Lance

Lance 是一种面向 AI 的开放多模态数据湖表格式。Lance 表不仅可以原生存储文本和标量值，还可以与您的表格数据一起存储图像、音频和视频等大型二进制对象（blobs）。

>>> from datasets import load_dataset
>>> lance_base_url = "lance-format/laion-1m"

若要流式加载数据集而无需将其复制到本地机器，请指定 streaming=True 参数：

ds = load_dataset(lance_base_url, split="train", streaming=True)
# Take first three rows
for row in ds.take(3):
    print(row["caption"], row["image"])

这将通过单次请求返回图像描述和图像字节。

Vortex

Vortex 是一种专为快速扫描压缩数据而设计的列式文件格式。使用 pip install vortex-data 安装后，即可像加载其他打包格式一样加载 .vortex 文件：

>>> from datasets import load_dataset
>>> dataset = load_dataset("vortex", data_files="data.vortex", split="train")

列和过滤条件会下推到 Vortex 扫描中，因此只会读取你请求的行和列。在流式处理时同样适用，这使得你可以在 Hub 上过滤数据集，而无需下载不匹配的部分：

>>> filters = [("label", "==", 1)]
>>> dataset = load_dataset(vortex_dataset_id, columns=["text", "label"], filters=filters, streaming=True, split="train")

Filters 采用与 Parquet 加载器相同的析取范式：一个 (column, operator, value) 谓词列表表示合取，而这些列表的列表表示析取。空值遵循 SQL 语义——空值不满足任何比较，因此被过滤列值为空的行永远不会被返回，包括 not in。对于该形式无法表达的内容，请改为传入 Vortex 表达式：

>>> import vortex.expr as ve
>>> dataset = load_dataset(vortex_dataset_id, filters=ve.column("score") >= 0.5, split="train")

Vortex 自行打开文件，而非通过 fsspec，因此 data_files 可以指向本地路径、Hub 数据集以及 Vortex 原生读取的远程位置（HTTP 和常见的对象存储）——但不能指向归档文件内部（zip://...）或其他仅支持 fsspec 的协议。

HDF5 文件

HDF5 文件常用于在科学计算和机器学习中存储大量数值数据。使用 🤗 Datasets 加载 HDF5 文件与加载 CSV 文件类似：

>>> from datasets import load_dataset
>>> dataset = load_dataset("hdf5", data_files="data.h5")

请注意，HDF5 加载器假定文件具有“表格”结构，即文件中所有数据集在第一维度上具有（相同数量的）行。

TsFile

TsFile 是一种专为时间序列数据设计的列式文件格式，用作 Apache IoTDB 的原生存储层。它原生表示时间戳、设备标签和测量字段，并维护内部时间索引，从而实现高效的时间范围裁剪。

结果数据集中的每一行对应一个 device（由其 TAG 列标识）；time 列和每个 FIELD 列都是列表列，包含该设备的完整时间序列，并按时间升序排列。

要加载 TsFile：

>>> from datasets import load_dataset
>>> dataset = load_dataset("tsfile", data_files="my_data.tsfile")

按时间范围过滤 — 边界条件会下推至 TsFile 的内部时间索引，并接受 int 时间戳、datetime、date、ISO-8601 字符串或 pyarrow 时间戳标量：

>>> from datetime import datetime
>>> dataset = load_dataset(
...     "tsfile",
...     data_files="my_data.tsfile",
...     start_time=datetime(2023, 11, 14),
...     end_time=datetime(2023, 11, 15),
... )

有关更多详细信息，请参阅如何加载 TsFile 数据指南。

Harbor

Harbor 数据集是由用于评估 AI 智能体的 任务 组成的集合。 它们由目录而非数据文件构成：每个任务都是一个目录，其中包含 task.toml 配置文件和 instruction.md 文件，以及其环境、验证器和解决方案。

结果数据集中的每一行描述一个任务（其指令、其 task.toml、其随附的文件）， 加载它时不会运行任何内容：

>>> from datasets import load_dataset
>>> dataset = load_dataset("harborframework/terminal-bench")
>>> dataset["train"][0]["task_id"]
'tasks/atrx-vep-crispr'

有关更多详细信息，请参阅如何加载智能体评估任务指南。

PDB

PDB（Protein Data Bank，蛋白质数据库）是一种用于表示三维大分子结构的传统定宽格式。尽管 mmCIF 是现代标准，但 PDB 仍被广泛使用，许多历史数据集也采用此格式。

每一行对应一个结构文件，遵循与 ImageFolder 相同的文件夹布局：子文件夹名称作为标签，metadata.csv/metadata.jsonl 文件用于添加每个结构的元数据。structure 列使用 BioStructure 并设置 format="pdb"，解码后得到一个 Bio.PDB.Structure.Structure 对象，其中包含该文件的模型、链、残基和原子。解码需要 biopython；若未安装，访问已解码的结构将引发 ImportError。

要从目录中加载 PDB 文件：

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("pdb", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='pdb', decode=True)

要访问未解码的底层 {"bytes": ..., "path": ...} 字典，且无需依赖 biopython，请使用 decode=False 转换该列：

>>> dataset = dataset.cast_column("structure", BioStructure(format="pdb", decode=False))

支持 .pdb 和 .ent 扩展名。

SQL

通过指定用于连接数据库的 URI，使用 from_sql() 读取数据库内容。您可以读取表名和查询：

>>> from datasets import Dataset
# load entire table
>>> dataset = Dataset.from_sql("data_table_name", con="sqlite:///sqlite_file.db")
# load from query
>>> dataset = Dataset.from_sql("SELECT text FROM table WHERE length(text) > 100 LIMIT 10", con="sqlite:///sqlite_file.db")

有关更多详细信息，请参阅如何从 SQL 数据库加载表格数据集指南。

WebDataset

WebDataset 格式基于 TAR 归档，适用于大型图像数据集。 由于其体积较大，WebDataset 通常以流式模式加载（使用 streaming=True）。

您可以按以下方式加载 WebDataset：

>>> from datasets import load_dataset
>>>
>>> path = "path/to/train/*.tar"
>>> dataset = load_dataset("webdataset", data_files={"train": path}, split="train", streaming=True)

要通过 HTTP 加载远程 WebDatasets，请传入 URL：

>>> from datasets import load_dataset
>>>
>>> base_url = "https://huggingface.co/datasets/lhoestq/small-publaynet-wds/resolve/main/publaynet-train-{i:06d}.tar"
>>> urls = [base_url.format(i=i) for i in range(4)]
>>> dataset = load_dataset("webdataset", data_files={"train": urls}, split="train", streaming=True)

mmCIF

mmCIF（macromolecular Crystallographic Information File，大分子晶体学信息文件）是表示三维大分子结构的现代标准格式，自 2014 年起被蛋白质数据库（PDB）采用。

每一行对应一个结构文件，遵循与 ImageFolder 相同的文件夹布局：子文件夹名称作为标签，metadata.csv/metadata.jsonl 文件用于添加每个结构的元数据。structure 列使用 BioStructure 并设置 format="mmcif"，解码后得到一个 Bio.PDB.Structure.Structure 对象，其中包含该文件的模型、链、残基和原子。解码需要 biopython；若未安装，访问已解码的结构将引发 ImportError。

要从目录中加载 mmCIF 文件：

>>> from datasets import BioStructure, load_dataset
>>> dataset = load_dataset("mmcif", data_dir="path/to/structures")
>>> dataset["train"].features["structure"]
BioStructure(format='mmcif', decode=True)

要访问未解码的底层 {"bytes": ..., "path": ...} 字典，且无需依赖 biopython，请使用 decode=False 转换该列：

>>> dataset = dataset.cast_column("structure", BioStructure(format="mmcif", decode=False))

支持 .cif 和 .mmcif 扩展名。

GenBank

GenBank 是 NCBI 提供的一种基于文本的格式，用于表示核苷酸和蛋白质序列及其注释。文件使用 .gb、.gbk 或 .genbank 扩展名（可选压缩），每条记录的 FEATURES 部分会被解码为结构化对象。

除了轻量级的解析列之外，每一行还包含一个类型为 BioSequence(format="genbank") 的 record 列，当安装了 biopython 时，该列会解码为 Bio.SeqRecord.SeqRecord。将此列转换为 BioSequence(format="genbank", decode=False) 即可将原始记录字节作为 {"bytes": ..., "path": None} 访问，或者使用 columns=[...] 省略该列，从而在不使用 biopython 的情况下仅使用解析后的列。

要加载 GenBank 文件：

>>> from datasets import load_dataset
>>> dataset = load_dataset("genbank", data_files="*.gb", split="train")

您可以在一个包含真实 NCBI 记录的小型示例数据集上尝试（其中一条记录经过 gzip 压缩，以展示压缩文件可以透明加载）：

>>> from datasets import load_dataset
>>> dataset = load_dataset("ermiaazarkhalili/datasets-genbank-test", data_files="*.gb*", split="train")
>>> dataset[0]["locus_name"], dataset[0]["organism"], dataset[0]["length"]

FASTQ

FASTQ 是一种基于文本的格式，用于存储核苷酸序列及其质量分数，广泛应用于高通量测序数据。

加载 FASTQ 文件：

>>> from datasets import load_dataset
>>> dataset = load_dataset("fastq", data_files="reads.fq")

加载器返回五列：

列类型描述
idstring序列标识符（@ 后的第一个词）
descriptionstring完整描述行（id 之后的所有内容）
sequencelarge_string核苷酸序列
qualitylarge_stringASCII 编码的质量分数
recordBioSequence使用 format="fastq" 时，会存储每条记录的原始字节，并在访问时解码为 Biopython 的 SeqRecord。

读取解析后的列无需 Biopython；使用 columns 排除 record，或使用 dataset.cast_column("record", BioSequence(decode=False))（从 datasets 导入）以在不解码的情况下访问其 {"bytes": ..., "path": None} 存储。

仅加载特定列：

>>> dataset = load_dataset("fastq", data_files="reads.fq", columns=["sequence", "quality"])

压缩文件（.fq.gz、.fastq.gz、.fq.bz2、.fq.xz）会被自动检测并解压。

FASTA

FASTA 是一种基于文本的格式，用于表示核苷酸序列（DNA/RNA）或肽序列（蛋白质），在生物信息学中被广泛使用。

要加载 FASTA 文件：

>>> from datasets import load_dataset
>>> dataset = load_dataset("fasta", data_files="sequences.fasta")

这将返回一个具有以下列的数据集：

  • id：序列标识符（> 后的第一个词）
  • description：完整描述行（id 之后的所有内容）
  • sequence：生物序列（DNA/RNA/蛋白质）
  • record：一个 BioSequence，其 format="fasta" 存储了每条记录的原始字节，在访问时会解码为 Biopython 的 SeqRecord。

读取解析后的列无需 Biopython；使用 columns 排除 record，或使用 dataset.cast_column("record", BioSequence(decode=False))（从 datasets 导入）以在不解码的情况下访问其 {"bytes": ..., "path": None} 存储。

您也可以仅加载特定的列：

>>> dataset = load_dataset("fasta", data_files="sequences.fa", columns=["id", "sequence"])

支持多种扩展名的 FASTA 文件：.fa、.fasta、.fna（核酸）、.ffn（基因区域的核苷酸）、.faa（氨基酸）以及 .frn（非编码 RNA）。压缩文件（gzip、bzip2、xz）会被自动检测并解压。

远程文件

如果您有远程文件，可能以 csv、json、txt、parquet 或任何受支持的格式存储，只要指定它们的远程路径，load_dataset() 函数就可以加载它们：

  • https:// 用于公开在线文件的 URL，例如 data_files=["https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json"]
  • Hugging Face 上任意 数据集仓库 或 存储桶 中文件的 hf:// URL，例如 data_files=["hf://datasets/karpathy/tinystories-gpt4-clean/tinystories_gpt4_clean.parquet"] 或 data_files=["hf://buckets/julien-c/my-training-bucket/julien/affluence.csv"]

多进程

当数据集由多个文件（我们称之为“分片”）组成时，可以显著加快数据集的下载和准备步骤。

您可以使用 num_proc 来选择用于并行准备数据集的进程数量。 在这种情况下，每个进程会被分配一个分片（shards）子集进行准备：

from datasets import load_dataset

imagenet = load_dataset("timm/imagenet-1k-wds", num_proc=8)
ml_librispeech_spanish = load_dataset("facebook/multilingual_librispeech", "spanish", num_proc=8)

内存中的数据

🤗 Datasets 还允许您直接从内存数据结构（如 Python 字典和 Pandas DataFrame）创建 Dataset。

Python 字典

使用 from_dict() 加载 Python 字典：

>>> from datasets import Dataset
>>> my_dict = {"a": [1, 2, 3]}
>>> dataset = Dataset.from_dict(my_dict)

Python 字典列表

使用 from_list() 加载 Python 字典列表：

>>> from datasets import Dataset
>>> my_list = [{"a": 1}, {"a": 2}, {"a": 3}]
>>> dataset = Dataset.from_list(my_list)

Python 生成器

使用 from_generator() 从 Python 生成器创建数据集：

>>> from datasets import Dataset
>>> def my_gen():
...     for i in range(1, 4):
...         yield {"a": i}
...
>>> dataset = Dataset.from_generator(my_gen)

这种方法支持加载大于可用内存的数据。

你还可以通过向 gen_kwargs 传递列表来定义分片数据集：

>>> 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

Pandas DataFrame

使用 from_pandas() 加载 Pandas DataFrame：

>>> from datasets import Dataset
>>> import pandas as pd
>>> df = pd.DataFrame({"a": [1, 2, 3]})
>>> dataset = Dataset.from_pandas(df)

有关更多详细信息，请参阅如何从 Pandas DataFrame 加载表格数据集指南。

离线

即使没有互联网连接，仍然可以加载数据集。只要您之前从 Hub 仓库下载过该数据集，它应该已被缓存。这意味着您可以从缓存中重新加载数据集并在离线状态下使用它。

如果您确定无法访问互联网，可以以完全离线模式运行 🤗 Datasets。这样可以节省时间，因为 🤗 Datasets 会直接查找缓存，而无需等待 Dataset builder 下载超时。将环境变量 HF_HUB_OFFLINE 设置为 1 即可启用完全离线模式。

Slice 拆分

您也可以选择仅加载某个 split 的特定切片。对 split 进行切片有两种方式：使用字符串或使用 ReadInstruction API。对于简单情况，字符串更紧凑且易读；而 ReadInstruction 则更便于使用可变的切片参数。

通过以下方式拼接 train 和 test 拆分：

>>> train_test_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train+test")

选择 train 数据集中的特定行：

>>> train_10_20_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[10:20]")

或者使用以下方法选择某个 split 的百分比：

>>> train_10pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]")

从每个数据集中选择百分比的组合：

>>> train_10_80pct_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[:10%]+train[-80%:]")

最后，你甚至可以创建交叉验证划分。下面的示例创建了 10 折交叉验证划分。每个验证数据集是一个 10% 的块，而训练数据集则构成剩余的互补 90% 块：

>>> val_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[{k}%:{k+10}%]" for k in range(0, 100, 10)])
>>> train_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=[f"train[:{k}%]+train[{k+10}%:]" for k in range(0, 100, 10)])

百分比切片和舍入

默认行为是，对于请求的切片边界无法被 100 整除的数据集，将边界四舍五入到最接近的整数。如下所示，某些切片可能包含比其他切片更多的样本。例如，如果以下 train 分割包含 999 条记录，则：

# 19 records, from 500 (included) to 519 (excluded).
>>> train_50_52_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%]")
# 20 records, from 519 (included) to 539 (excluded).
>>> train_52_54_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%]")

如果您希望各部分大小相等，请改用pct1_dropremainder舍入方式。这种方式将指定的百分比边界视为 1% 的倍数。

# 18 records, from 450 (included) to 468 (excluded).
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train", from_=50, to=52, unit="%", rounding="pct1_dropremainder"))
# 18 records, from 468 (included) to 486 (excluded).
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split=datasets.ReadInstruction("train",from_=52, to=54, unit="%", rounding="pct1_dropremainder"))
# Or equivalently:
>>> train_50_52pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[50%:52%](pct1_dropremainder)")
>>> train_52_54pct1_ds = datasets.load_dataset("ajibawa-2023/General-Stories-Collection", split="train[52%:54%](pct1_dropremainder)")

pct1_dropremainder 舍入方式可能会截断数据集中的最后几个样本，如果您的数据集样本总数不能被 100 整除。

故障排除

有时，加载数据集时可能会得到意外结果。您最常遇到的两个问题是手动下载数据集以及指定数据集的特征。

指定功能

从本地文件创建数据集时，Features 会由 Apache Arrow 自动推断。不过，数据集的特征可能并不总是符合您的预期，或者您可能希望自行定义特征。以下示例展示了如何使用 ClassLabel 特征添加自定义标签。

首先使用 Features 类定义你自己的标签：

>>> class_names = ["sadness", "joy", "love", "anger", "fear", "surprise"]
>>> emotion_features = Features({'text': Value('string'), 'label': ClassLabel(names=class_names)})

接下来，在 load_dataset() 中指定 features 参数，使用你刚刚创建的特征：

>>> dataset = load_dataset('csv', data_files=file_dict, delimiter=';', column_names=['text', 'label'], features=emotion_features)

现在，当你查看数据集的特征时，可以看到它使用了你定义的自定义标签：

>>> dataset['train'].features
{'text': Value('string'),
'label': ClassLabel(names=['sadness', 'joy', 'love', 'anger', 'fear', 'surprise'])}
Update on GitHub

←概述 流程→