数学基础

统计学习

文章来源于网络收集而来，版权归原创者所有，如有侵权请及时联系！

三、API

发布于 2023-07-17 23:38:23 字数 130288 浏览 0 评论 0 收藏 0

3.1 DatasetInfo

DatasetInfo：包含数据集的信息。
```
xxxxxxxxxx
class datasets.DatasetInfo( description: str = <factory>, citation: str = <factory>, homepage: str = <factory>, license: str = <factory>, features: typing.Optional[datasets.features.features.Features] = None, post_processed: typing.Optional[datasets.info.PostProcessedInfo] = None, supervised_keys: typing.Optional[datasets.info.SupervisedKeysData] = None, task_templates: typing.Optional[typing.List[datasets.tasks.base.TaskTemplate]] = None, builder_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, version: typing.Union[str, datasets.utils.version.Version, NoneType] = None, splits: typing.Optional[dict] = None, download_checksums: typing.Optional[dict] = None, download_size: typing.Optional[int] = None, post_processing_size: typing.Optional[int] = None, dataset_size: typing.Optional[int] = None, size_in_bytes: typing.Optional[int] = None )
```
参数：
- description：一个字符串，指定数据集的描述。
- citation：一个字符串，指定数据集的 BibTeX citation 。
- homepage：一个字符串，指定数据集的官方 URL 。
- license：一个字符串，指定数据集的 licence。
- features：一个 Features 对象，指定数据集的特征。
- post_processed：一个 PostProcessedInfo 对象，指定数据集的后处理信息。
- supervised_keys：一个 SupervisedKeysData 对象，指定用于监督学习的 input feature 和 label （如果该数据集有的话）。
- builder_name：一个字符串，指定创建数据集的 GeneratorBasedBuilder 子类的名称。通常与相应的 script name 相匹配。它也是 dataset builder class name 的 snake_case 版本。
- config_name ：一个字符串，指定从 BuilderConfig 派生的配置的名称。
- version：一个字符串，指定数据集的版本。
- splits：一个字典，指定 split name 和 metadata 之间的映射。
- download_checksums：一个字典，指定 URL 到被下载的数据集 checksum 和对应 metadata 之间的映射。
- download_size：一个整数，指定为生成数据集而下载的文件的大小（单位字节）。
- post_processing_size：一个整数，指定后处理之后数据集的大小（单位字节）。
- dataset_size：一个整数，指定所有 split 的 Arrow table 的组合后的大小（单位字节）。
- size_in_bytes：一个整数，指定数据集关联的所有文件的总大小（包括下载的文件和 Arrow 文件，单位字节）。
- task_templates：TaskTemplate 的一个列表，指定训练和评估期间预处理数据集的 task template 。每个模板都将数据集的 Features 转换为标准化的列名和类型。
- config_kwargs：额外的关键字参数，传递给 BuilderConfig 并在 DatasetBuilder 中使用。
注意：这些属性在 DatasetInfo 创建时被赋值，并可能在随后被更新。
方法：
- from_directory(dataset_info_dir: str, fs = None) ：从dataset_info_dir 中的 JSON 文件中创建 DatasetInfo 。它将重写所有的 DatasetInfo 的 metadata 。
  参数：
  - dataset_info_dir：一个字符串，指定存放 metadata file 的目录。
  - fs：一个 fsspec.spec.AbstractFileSystem，指定从哪里下载文件。
- write_to_directory(dataset_info_dir, pretty_print = False, fs = None)：将 DatasetInfo 和 license 写入 dataset_info_dir 中的 JSON 文件。
  参数：
  - pretty_print：一个布尔值，指定 JSON 是否是 pretty-printed 的。
  - 其它参数参考 from_directory() 。

3.2 Dataset

Dataset：数据集的基类，基于 Apache Arrow table 来实现。
```
xxxxxxxxxx
class datasets.Dataset(arrow_table: Table,
        info: Optional[DatasetInfo] = None,
        split: Optional[NamedSplit] = None,
        indices_table: Optional[Table] = None,
        fingerprint: Optional[str] = None,
    )
```
参数：文档未指定，源码也没有。
属性：
- info：返回一个 DatasetInfo 对象，包含数据集中的所有 metadata。
- split：返回一个 NamedSplit 对象，对应于 named dataset split 。
- builder_name/citation/config_name/dataset_size/description/download_checksums/download_size/features/homepage/license/size_in_bytes/supervised_keys/version：参考 DatasetInfo 的属性。
- format：返回一个字典，表示数据集的格式。
- shape：返回一个 Tuple[int, int]，表示数据集的形状（列数，行`数）。
- column_names：返回一个字符串列表，表示数据集的列名。
- num_rows：返回一个整数，表示数据集的行数。
- num_columns：返回一个整数，表示数据集的列数。
- cache_files：返回一个字典的列表，表示数据集背后的、包含 Apache Arrow table 的缓存文件。
- data：返回一个 Tabe 对象，表示数据集背后的 Apache Arrow table 。
方法：
- add_column(name: str, column: Union[list, np.array], new_fingerprint: str) -> Dataset ：向数据集中添加列。
  参数：
  - name：一个字符串，指定列名。
  - column：一个列表或 np.array，指定列数据。
  - new_fingerprint：一个字符串，指定新的指纹。
  返回一个 Dataset 。
- add_item(item: dict, new_fingerprint: str) -> Dataset：向数据集中添加一行。
  参数：
  - item：一个字典，指定行数据。字典的 key 就是列名，需要提供全部列名。
  - 其它参数参考 add_column 。
  返回一个 Dataset 。
- from_file()：从 Arrow table 的文件中初始化一个数据集。
```
xxxxxxxxxx
from_file(filename: str,
        info: Optional[DatasetInfo] = None,
        split: Optional[NamedSplit] = None,
        indices_filename: Optional[str] = None,
        in_memory: bool = False,
    ) -> Dataset
```
  参数：
  - filename：一个字符串，指定数据集的文件名。
  - info：一个 DatasetInfo 对象，指定数据集的信息。
  - split：一个 NamedSplit 对象，指定数据集的 split 。
  - indices_filename：一个字符串，指定索引的文件名。
  - in_memory：一个布尔值，指定是否将数据拷贝到内存。
  返回一个 Dataset 。
- from_buffer()：从 Arrow buffer 中初始化一个数据集。
```
xxxxxxxxxx
from_buffer(buffer: pa.Buffer,
        info: Optional[DatasetInfo] = None,
        split: Optional[NamedSplit] = None,
        indices_buffer: Optional[pa.Buffer] = None,
    ) -> Dataset
```
  参数：
  - buffer：一个 pyarrow.Buffer ，指定 Arrow buffer 。
  - indices_buffer：一个 pyarrow.Buffer ，指定索引的 Arrow buffer 。
  - 其它参数参考 from_file() 。
  返回一个 Dataset 。
- from_pandas()：从 pandas.DataFrame 转换为一个 pyarrow.Table 进而创建一个数据集。
  Arrow Table 中的列类型是从 DataFrame 中的 pandas.Series 中推断而来。在 non-object Series 的情况下，Numpy dtype 被直接转换为对应的 Arrow 类型。在 object Series 的情况下，我们需要查看 Series 中的 Python object 来猜测数据类型。
  注意：object Series 可能没有包含足够的信息来推断 Arrow 类型，例如 DataFrame 的长度为零、或者 Series 仅包含 None/nan 对象，此时 Arrow type 被设为 null 。可以通过构造显式的 features 来避免。
```
xxxxxxxxxx
from_pandas(df: pd.DataFrame,
        features: Optional[Features] = None,
        info: Optional[DatasetInfo] = None,
        split: Optional[NamedSplit] = None,
        preserve_index: Optional[bool] = None,
    ) -> Dataset
```
  参数：
  - df：一个 pandas.DataFrame 对象，指定数据集的数据内容。
  - features：一个 Features 对象，指定数据集的特征。
  - preserve_index：一个布尔值，指定是否将 pandas 索引存储为数据集中的额外的列。
    默认值为 None，表示将索引存储为额外的列（RangeIndex 除外，它仅被存储为 metadata）。使用 True，则强制将索引存储为列（包括 RangeIndex）。
  - 其它参数参考 from_file() 。
  返回一个 Dataset 。
- from_dict()：从字典转换为一个 pyarrow.Table 进而创建一个数据集。
```
xxxxxxxxxx
from_dict(mapping: dict,
        features: Optional[Features] = None,
        info: Optional[DatasetInfo] = None,
        split: Optional[NamedSplit] = None,
    ) -> Dataset
```
  参数：
  - mapping：一个字典对象，指定数据集的数据内容，它将字符串映射到 Array 或 Python 列表。
  - 其它参数参考 from_pandas() 。
  返回一个 Dataset 。
- from_list()：从字典的列表转换为一个 pyarrow.Table 进而创建一个数据集。
```
xxxxxxxxxx
from_list(mapping: List[dict],
        features: Optional[Features] = None,
        info: Optional[DatasetInfo] = None,
        split: Optional[NamedSplit] = None,
    ) -> Dataset
```
  参数：
  - mapping：一个字典的列表，其中每个字典代表一行数据，字典的 key 就是列名，需要提供全部列名。
  - 其它参数参考 from_dict() 。
  返回一个 Dataset 。
- from_csv()：从 CSV 文件中创建数据集。
```
xxxxxxxxxx
from_csv(path_or_paths: Union[PathLike, List[PathLike]],
        split: Optional[NamedSplit] = None,
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        **kwargs,
    ) -> Dataset
```
  参数：
  - path_or_paths：一个 path-like 对象或者 path-like 对象的列表，指定 CSV 文件的路径。
  - split：一个 NamedSplit 对象，指定被赋予到数据集上的 split name 。
  - features：一个 Features 对象，指定数据集特征。
  - cache_dir：一个字符串，指定缓存数据的目录。默认为 "~/.cache/huggingface/datasets" 。
  - keep_in_memory：一个布尔值，指定是否拷贝数据到内存。
  - **kwargs：关键字参数，传递给 padans.read_csv() 。
  返回一个 Dataset 。
- from_generator()：从迭代器中创建一个数据集。
```
xxxxxxxxxx
from_generator(
        generator: Callable,
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        gen_kwargs: Optional[dict] = None,
        **kwargs,
    ) -> Dataset
```
  参数：
  - generator：一个可调用对象，表示一个 generator function，它可以 yield 样本。
  - gen_kwargs：一个字典，它作为关键字参数被传递给 generator 。你可以定义一个分片的数据集，其中在 gen_kwargs 中传递分片列表。
  - kwargs：额外的关键字参数，用于传递给 GeneratorConfig 。
  - 其它参数参考 from_csv()。
  返回一个 Dataset 。
  示例（分片数据集）：
```
xxxxxxxxxx
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})
```
- from_json()：从 JSON 文件中创建数据集。
```
xxxxxxxxxx
from_json(path_or_paths: Union[PathLike, List[PathLike]],
        split: Optional[NamedSplit] = None,
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        field: Optional[str] = None,
        **kwargs,
    ) -> Dataset
```
  参数：
  - field：一个字符串，指定数据集被包含在JSON 文件的哪个字段，所对应的 field name 。
  - kwargs：关键字参数，传递给 JsonConfig 。
  - 其它参数参考 from_csv() 。
  返回一个 Dataset 。
- from_parquet()：从 Parquet 文件中创建数据集。
```
xxxxxxxxxx
from_parquet(path_or_paths: Union[PathLike, List[PathLike]],
        split: Optional[NamedSplit] = None,
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        columns: Optional[List[str]] = None,
        **kwargs,
   ) -> Dataset
```
  参数：
  - columns：一个字符串的列表，如果不是 None，那么仅从文件中读取这些列。可以进行嵌套，如 a.b, a.d.e 。
  - kwargs：关键字参数，传递给 ParquetConfig 。
  - 其它参数参考 from_csv() 。
  返回一个 Dataset 。
- from_text()：从文本文件中创建数据集。
```
xxxxxxxxxx
from_text(path_or_paths: Union[PathLike, List[PathLike]],
        split: Optional[NamedSplit] = None,
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        **kwargs,
    ) -> Dataset
```
  返回一个新的 Dataset 。
  参数：
  - kwargs：关键字参数，传递给 TextConfig 。
  - 其它参数参考 from_csv() 。
  返回一个 Dataset 。
- from_sql()：从 SQL query 或 database table 中创建数据集。
```
xxxxxxxxxx
from_sql(
        sql: Union[str, "sqlalchemy.sql.Selectable"],
        con: Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"],
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        **kwargs,
    ) -> Dataset
```
  参数：
  - sql：一个字符串或者 sqlalchemy.sql.Selectable 对象，指定一个 table name 或者待执行的 sql query 。
  - con：一个字符串或者 sqlalchemy.engine.Connection 或者 sqlalchemy.engine.Engine 或者 sqlite3.Connection ，用于初始化一个 database connection 。
  - **kwargs：关键字参数，用于 SqlConfig 。
  - 其它参数参考 from_csv() 。
  返回一个 Dataset 。
- unique( column: str ) -> list：返回指定列的 unique element 的列表。
  参数：column：一个字符串，指定列名。
  返回值：该列 unique 元素组成的列表。
- flatten(new_fingerprint: Optional[str] = None, max_depth=16) -> Dataset：对数据集的所有列进行展平，返回当前数据集的、列被展平了的 copy 。每个 struct type 列被展平为：每个 struct filed 一个列。非 struct type 列被保留。
  参数：
  - new_fingerprint：一个字符串，指定数据集经过变换之后的新的指纹。如果为 None，那么这个新的指纹是基于一个哈希来计算得到，这个哈希考虑了前一个指纹、以及 transform argument 。
  - max_depth：一个整数，指定最多展平多少层。
  返回一个 Dataset （拷贝后的新数据集）。
- cast()：对数据集的列进行类型强制转换，返回当前数据集的被类型转换的 copy 。
```
xxxxxxxxxx
cast(features: Features,
        batch_size: Optional[int] = 1000,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        num_proc: Optional[int] = None,
    ) -> Dataset
```
  参数：
  - features：一个 Features 对象，指定数据集要强制转换的新的 features 。features 的字段名必须匹配当前的列名。并且底层的数据能够支持转换到目标类型。对于困难的转换，如 string <-> ClassLabel，你必须使用 map 来进行转换。
  - batch_size：一个整数，指定强制类型转换的每个 batch 的样本数。如果 batch_size <= 0 或者 batch_size == None，那么将整个数据集作为单个 batch 来强制类型转换。
  - keep_in_memory：一个布尔值，是否拷贝数据到内存中。
  - load_from_cache_file：一个布尔值，如果一个缓存文件已经存储了当前的计算，那么使用这个缓存文件而不是重新计算。
  - cache_file_name：一个字符串，指定缓存文件的路径名。如果未指定，则自动生成缓存文件名。
  - writer_batch_size：一个整数，指定 cache file writer 每次写操作时写入多少行。该值是内存占用和处理速度之间的 trade-off：取值越大则处理速度更快（因为查找次数更少），取值越小则内存占用更少。
  - num_proc：一个整数，指定多进程处理时的进程数。默认不使用多进程。
  返回一个 Dataset （拷贝后的新数据集）。
- cast_column(column: str, feature: FeatureType, new_fingerprint: Optional[str] = None) -> Dataset：强制类型转换指定的列。
  参数：
  - column：一个字符串，指定列名。
  - feature：一个 FeatureType 对象，表示目标的类型。
  - new_fingerprint：参考 cast() 。
  返回一个 Dataset 。
- remove_columns(column_names: Union[str, List[str]], new_fingerprint: Optional[str] = None) -> Dataset：返回数据集的一个 copy 版本，该版本移除数据集中的某些列及其关联的内容。
  参数：
  - column_names：一个字符串或者字符串列表，指定要被移除的列。
  - new_fingerprint：参考 cast() 。
  返回一个 Dataset （拷贝后的新数据集）。
  你也可以通过带 remove_columns 的 Dataset.map() 方法来移除列，但是 map() 方法是原地修改（而不会拷贝一个新的数据集），因此速度更快。
- rename_column( original_column_name: str, new_column_name: str, new_fingerprint: Optional[str] = None) -> Dataset：返回数据集的一个 copy 版本，该版本重命名了数据集的指定列。
  参数：
  - original_column_name：一个字符串，指定旧的列名。
  - new_column_name：一个字符串，指定新的列名。
  - new_fingerprint：参考 cast() 。
  返回一个 Dataset （拷贝后的新数据集）。
- rename_columns(column_mapping: Dict[str, str], new_fingerprint: Optional[str] = None) -> Dataset：返回数据集的一个 copy 版本，该版本重命名了数据集的一些列。
  参数：
  - column_mapping：一个字典，键为旧的列名、值为新的列名。
  - new_fingerprint：参考 cast() 。
  返回一个 Dataset （拷贝后的新数据集）。
- class_encode_column(column: str, include_nulls: bool = False) -> Dataset：将指定的列强制类型转换为 datasets.features.ClassLabel ，并更新数据集。
  参数：
  - column：一个字符串，指定被强制类型转换的列名。
  - include_nulls：一个布尔值，指定 class label 中是否包含 null value 。如果为 True，则 null value 被编码为 None 。
  返回一个 Dataset 。
- __len__() -> int：返回数据集的行数。
- __iter__() ：迭代从而每次迭代产生样本。如果已经通过 Dataset.set_format() 来设置了格式，那么迭代返回的 row 将具有指定的格式。
- formatted_as()：用于在 with 表达式中使用，它设置了 __getitem__ 所返回的格式。
```
xxxxxxxxxx
formatted_as(type: Optional[str] = None,
        columns: Optional[List] = None,
        output_all_columns: bool = False,
        **format_kwargs,
    )
```
  参数：
  - type：一个字符串，指定输出类型，可以为 None, 'numpy', 'torch', 'tensorflow', 'pandas', 'arrow' 。None 意味着 __getitem__ 返回 Python 对象。
  - columns：一个字符串列表，指定输出中哪些列需要被格式化。None 意味着 __getitem__ 返回所有的列。
  - output_all_columns：一个布尔值，指定是否在输出中保留 un-formatted 列（作为 python 对象）。
  - **format_kwargs：关键字参数，被传递给一些转换函数，如 np.array, torch.tensor, tensorflow.ragged.constant 。
  可以通过 Dataset.format 来查看数据集的格式。
- set_format()：设置 getitem 所返回的格式。数据格式化是 on-the-fly 应用的。
```
xxxxxxxxxx
set_format(type: Optional[str] = None,
        columns: Optional[List] = None,
        output_all_columns: bool = False,
        **format_kwargs,
    )
```
  参数：参考 formatted_as() 。
  也可以通过 Dataset.set_transform() 来使用自定义的变换从而用于格式化。
  如果你在调用 Dataset.set_format() 之后再调用 Dataset.map() 从而创建一个新的列，那么这个新的列也会被格式化。
- set_transform()：利用 transform 来转换 getitem 所返回的内容。 transform 是 on-the-fly 应用到 batch 上的。
```
xxxxxxxxxx
set_transform(transform: Optional[Callable],
        columns: Optional[List] = None,
        output_all_columns: bool = False,
    )
```
  参数：
  - transform：一个可调用对象，给出了用户自定义的转换。它的输入是一个 batch （以字典的形式，键位列名、值为该列在 batch 内的值）作为输入并返回一个 batch 作为输出。这个可调用对象再 getitem 返回之前的时刻被调用。
  - columns：一个字符串列表，如果指定，则表示转换仅发生在这些列上，此时 transform 的输入仅包含这些列作为 key 的字典。
  - output_all_columns：一个布尔值，指定是否输出所有的列。如果为 True，则未包含在 transform 中的列也被输出。
- reset_format()：恢复 getitem 的格式为，对所有的列返回 python 对象。
- with_format()：设置 getitem 所返回的格式。几乎类似于 set_format() 。
```
xxxxxxxxxx
with_format(type: Optional[str] = None,
        columns: Optional[List] = None,
        output_all_columns: bool = False,
        **format_kwargs,
    )
```
  参数：参考 set_format()。
  Dataset.set_format() 是原地修改操作，而 Dataset.with_format() 返回一个新的Dataset。
- with_transform()：利用 transform 来转换 getitem 所返回的内容。几乎类似于 set_transform() 。
```
xxxxxxxxxx
with_transform(transform: Optional[Callable],
        columns: Optional[List] = None,
        output_all_columns: bool = False,
    )
```
  参数：参考 set_transform()。
  Dataset.set_transform() 是原地修改操作，而 Dataset.with_transform() 返回一个新的Dataset 。
- __getitem__(key)：用于对列索引（key 为列名字符串）或行索引（key 为整数索引、或者索引集合、或布尔值集合）。返回指定索引的值。
- cleanup_cache_files() -> int：清理数据集缓存目录中的所有缓存文件，当前使用的缓存文件（如果有的话）除外。
  返回被清除的文件的数量。
  运行此命令时要小心，确保当前没有其他进程正在使用其他缓存文件。
- map()：对数据集中每个样本执行一个函数（以单个样本的形式或 batch 的形式），并更新数据集。如果函数返回的列在数据集中已存在，则覆盖该列。
```
xxxxxxxxxx
map(function: Optional[Callable] = None,
        with_indices: bool = False,
        with_rank: bool = False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: Optional[int] = 1000,
        drop_last_batch: bool = False,
        remove_columns: Optional[Union[str, List[str]]] = None,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = None,
        cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        features: Optional[Features] = None,
        disable_nullable: bool = False,
        fn_kwargs: Optional[dict] = None,
        num_proc: Optional[int] = None,
        suffix_template: str = "_{rank:05d}_of_{num_proc:05d}",
        new_fingerprint: Optional[str] = None,
        desc: Optional[str] = None,
    ) -> Dataset
```
  参数：
  - function：一个可调用对象，它被应用到样本上。它的签名为：
    - 如果 batched=False 且 with_indices=False 且 with_rank=False ，那么函数签名为 function(example: Dict[str, Any]) -> Dict[str, Any] 。
    - 如果 batched=False 且 with_indices=True 且/或 with_rank=True ，那么函数签名为 function(example: Dict[str, Any], extra_args) -> Dict[str, Any] 。
      其中 extra_args 包含一个或两个参数，对应于 with_indices=True 且/或 with_rank=True 。
    - 如果 batched=True 且 with_indices=False 且 with_rank=False ，那么函数签名为 function(batch: Dict[str, List]) -> Dict[str, List] 。
    - 如果 batched=True 且 with_indices=True 且/或 with_rank=True ，那么函数签名为 function(batch: Dict[str, List], extra_args) -> Dict[str, List] 。
    对于更高级的用法，function 也可以返回一个 pyarrow.Table。此外，如果 function 返回 None，那么 map 将执行该 function 并保留数据集不变。如果没有提供 function，则默认为恒等映射：lambda x : x 。
  - with_indices：一个布尔值，指定是否提供样本索引作为 function 的输入。此时，function 的签名应该是 function(example, idx[, rank]) 。
  - with_rank：一个布尔值，指定是否将 rank 作为 function 的输入。此时，function 的签名应该是 function(example[, idx], rank) 。
    rank 是用于分布式环境。
  - input_columns：一个字符串或字符串列表，指定哪些列传递给 function （作为关键字参数）。如果为 None，则一个映射到所有格式化列的字典将被作为一个参数传递给 function 。
  - batched：一个布尔值，指定是否 batch 执行。如果为 True，那么传递给 function 的是一个 batch 的样本；否则传递给 function 的是单个样本。
  - batch_size：一个整数，指定 batch size 。当 batched = True 时才生效。如果 batched = True 且 batch size <= 0 或 batch size = None，则整个数据集作为一个 batch 。
  - drop_last_batch：一个布尔值，当最后一个 batch 的大小小于 batch_size 时，是否丢弃掉这个小的 batch 。当 batched = True 时才生效。
  - remove_columns：一个字符串或字符串列表，指定哪些列要被移除。这些列将在 function 执行之后、数据集样本更新之前被移除。例如，假设数据集的列为 ['a','b','c'] ，function 根据 'c' 创建了一个新的列 'new_c'，如果要移除列 ['b', 'c']，那么最终的数据集包含两列 ['a', 'new_c']（而不是仅有一列 ['a']）。
  - keep_in_memory：一个布尔值，指定是否保存数据集到内存中（而不是写入一个缓存文件）。`
  - load_from_cache_file：一个布尔值，当为 True 时，如果已经有一个缓存文件存储了 function 的计算，那么使用这个缓存文件而不是重新计算。当为 False 时，始终重新计算。
  - cache_file_name：一个字符串，指定缓存文件的路径名。用于 load_from_cache_file 。
  - writer_batch_size：一个整数，指定 cache file writer 每次写操作时写入多少行。
  - features：一个 Features 对象，指定一个特定的 Features 来存储缓存文件，而不是自动生成一个 Features 。
  - disable_nullable：一个布尔值，指定是否在数据集中不允许 null 值。
  - fn_kwargs：一个字典，用于为 function 提供关键字参数。
  - num_proc：一个整数，指定用于生成缓存的最大进程数量。
  - suffix_template：一个字符串，如果指定了 cache_file_name，那么 suffix_template 用于指定 cache_file_name 的后缀。默认的模板为 "_{rank:05d}_of_{num_proc:05d}" 。
    例如，假设 cache_file_name 为 ABC.arrow，而 rank=1, num_proc=4，那么最终的缓存文件名为 ABC_000001_of_000004.arrow 。
  - new_fingerprint ：一个字符串，指定新的指纹。如果为 None，则新的指纹根据一个哈希值来计算，这个哈希值来自于前一个指纹、以及 transform 参数。
  - desc：一个字符串，表示有意义的描述，用于进度条的展示。
  返回一个 Dataset 。
- filter()：应用一个 filter function 到数据集中所有的样本（以单个样本的形式或 batch 的形式），并更新数据集，使得数据集仅包含 filter function 返回为 True 的样本。
```
xxxxxxxxxx
filter( function: Optional[Callable] = None,
        with_indices=False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: Optional[int] = 1000,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        fn_kwargs: Optional[dict] = None,
        num_proc: Optional[int] = None,
        suffix_template: str = "_{rank:05d}_of_{num_proc:05d}",
        new_fingerprint: Optional[str] = None,
        desc: Optional[str] = None,
    ) -> Dataset
```
  参数：
  - function：一个可调用对象，它的签名类似于 map() 中的 function，但是这里的 function 必须返回一个布尔值（表示是否保留该样本）。
  - 其它参数参考 map()。
  返回一个 Dataset 。
- select()：创建一个新的数据集，这个新的数据集的row 是根据索引（以列表或 array 来提供）从原始数据集检索得到。
```
xxxxxxxxxx
select( indices: Iterable,
        keep_in_memory: bool = False,
        indices_cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        new_fingerprint: Optional[str] = None,
    ) -> Dataset
```
  参数：
  - indices：一个可迭代对象，表示一组索引。
    - 如果 indices 对应于一个连续的区间，那么 Arrow table 仅仅是简单的切片。
    - 如果 indices 对应于多个连续的区间，那么会创建索引映射 indices mapping 。
    - 否则，会创建一个新的 Arrow table 。
  - 其它参数参考 map()。
  返回一个新的 Dataset（样本粒度的拷贝）。
- sort()：创建一个新的数据集，该数据集根据指定的列来排序。
  目前使用 pandas 排序算法，因此该列必须是 pandas 兼容的类型（尤其不是嵌套类型）。这也意味着用于排序的列能够完全加载到内存中。
```
xxxxxxxxxx
sort( column: str,
        reverse: bool = False,
        kind: str = None,
        null_placement: str = "last",
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        indices_cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        new_fingerprint: Optional[str] = None,
    ) -> Dataset
```
  参数：
  - column：一个字符串，指定根据哪一列来排序。
  - reverse：一个布尔值，指定是否降序排列。如果为 True 则降序排列，否则升序排列。
  - kind：一个字符串，指定 pandas 排序算法，可以为 {'quicksort', 'mergesort', 'heapsort', 'stable'} ，默认为 'quicksort' 。注意，'stable'、'mergesort' 都在幕后使用 timsort ，一般而言，实际的实现会因为数据类型而异。
  - null_placement：一个字符串，指定 None 值应该排在头部（'first'）还是尾部（'last'）。
  - indices_cache_file_name：一个字符串，指定用于排序的索引的缓存文件名（而不是自动生成）。
  - 其它参数参考 map()。
  返回一个新的 Dataset（拷贝后的新数据集）。
- shuffle()：创建一个新的数据集，该数据集随机混洗了 row 。
  目前混洗使用 numpy 随机数生成器。
```
xxxxxxxxxx
shuffle( seed: Optional[int] = None,
        generator: Optional[np.random.Generator] = None,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        indices_cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        new_fingerprint: Optional[str] = None,
    ) -> Dataset
```
  参数：
  - seed：一个整数，当 generator = None 时指定随机数种子来初始化默认的 BitGenerator 。如果为 None，那么从操作系统中抽取新的、不可预测的 entropy 。
  - generator：一个 numpy.random.Generator ，指定随机数生成器。如果为 None，则默认为 BitGenerator(PCG64) 。
  - 其它参数参考 sort() 。
  返回一个新的 Dataset（拷贝后的新数据集）。
- train_test_split()：返回一个 datasets.DatasetDict，它具有两个随机拆分的子集（train 和 test 的 Dataset splits）。
  该方法类似于 scikit-learn 的 train_test_split() 。
```
xxxxxxxxxx
train_test_split(test_size: Union[float, int, None] = None,
        train_size: Union[float, int, None] = None,
        shuffle: bool = True,
        stratify_by_column: Optional[str] = None,
        seed: Optional[int] = None,
        generator: Optional[np.random.Generator] = None,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        train_indices_cache_file_name: Optional[str] = None,
        test_indices_cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        train_new_fingerprint: Optional[str] = None,
        test_new_fingerprint: Optional[str] = None,
    ) -> DatasetDict
```
  参数：
  - test_size：一个整数或浮点数，表示测试集大小。如果是整数，则表示测试集的绝对大小；如果是浮点数，则必须是 0.0 到 1.0 之间，表示测试集相对于整个数据集的比例。
    如果为 None，则测试集就自动设为训练集的补集；如果 test_size = None, train_size = None，那么默认为 test_size = 0.25, train_size = 0.75 。
  - train_size：一个整数或浮点数，表示训练集大小。参考 test_size 。
  - shuffle：一个布尔值，指定是否在拆分之前首先混洗数据集。
  - stratify_by_column：一个字符串，指定 label 列的列名，用于执行分层拆分（使得拆分之后，训练集/验证集中的 label 分布和整体数据集保持一致）。
  - 其它参数参考 shuffle() 。
  返回一个 datasets.DatasetDict。
- shard()：执行数据集分片，并返回第 index 个分片。
  确保在使用任何随机操作（如 shuffle()）之前执行分片。最好在 dataset pipeline 的早期使用分片操作。
```
xxxxxxxxxx
shard( num_shards: int,
        index: int,
        contiguous: bool = False,
        keep_in_memory: bool = False,
        indices_cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
    ) -> Dataset
```
  参数：
  - num_shards：一个整数，指定将数据集拆分为多少个分片。
  - index：一个整数，指定选择和返回第几个分片。
  - contiguous：一个布尔值，指定是否为分片选择连续的索引 block 。
  - 其它参数参考 shuffle() 。
  返回一个 Dataset 。
  分片算法是确定性的：
  - 如果 contiguous=False，那么dataset.shard(n, i) 将包含满足这种条件的样本：样本索引除以 n 的余数为 i 。
  - 如果 contiguous=True，那么dataset.shard(n, i) 将连续地分片，并且满足：datasets.concatenate([dataset.shard(n, i, contiguous=True) for i in range(n)]) 仍然等于 dataset 的样本及其原始顺序。
- to_tf_dataset()：根据底层的 Dataset 创建一个 tf.data.Dataset。这个 tf.data.Dataset 将从数据集中加载和 collate batch 数据，并适用于传递给 model.fit() 或 model.predict() 等方法。
  如果数据集同时包含 inputs 和 labels，那么这个数据集的 yield 将产生一个字典，该字典包含 inputs 和 labels 的键；如果没有 labels，那么 yield 仅包含一个原始的 tf.Tensor 。
```
xxxxxxxxxx
to_tf_dataset( batch_size: int,
        columns: Optional[Union[str, List[str]]] = None,
        shuffle: bool = False,
        collate_fn: Optional[Callable] = None,
        drop_remainder: bool = False,
        collate_fn_args: Optional[Dict[str, Any]] = None,
        label_cols: Optional[Union[str, List[str]]] = None,
        prefetch: bool = True,
    )
```
  参数：
  - batch_size：一个整数，指定 batch size 。
  - columns：一个字符串或字符串列表，指定 tf.data.Dataset 中包含当前数据集的哪些列。可以使用 collate_fn 创建的、但是不在 dataset 原始列中的列名。
  - shuffle：一个布尔值，指定是否在加载时混洗数据集。推荐在训练期间设置为 True，在验证和评估期间设置为 False 。
  - drop_remainder：一个布尔值，指定是否在加载时丢弃最后一个 incomplete batch 。
  - collate_fn：一个可调用对象，用于将 list of samples 转换为一个 batch 。
  - collate_fn_args：一个字典，作为关键字参数传递给 collate_fn 。
  - label_cols：一个字符串或字符串列表，指定哪一列是 label 列。因为有些模型在内部计算损失函数（而不是让 Keras 来计算），因此需要指定 label 列。
  - prefetch：一个布尔值，指定是否在独立的线程中运行 dataloader，并维持一个小 buffer 的 batch 数据用于训练，即 batch 预取。这可以提高性能。
  返回一个 tf.data.Dataset。
- push_to_hub()：将数据集作为一个 Parquet dataset 推送到 hub 上。推送是通过 HTTP 请求进行的，无需 git 或 git-lfs 。
  结果的 Parquet 文件是自包含的。如果你的数据集包含 Image 数据或 Audio 数据，那么 Parquet 文件将存储图片文件或音频文件的 bytes 。你可以通过设置 embed_external_files 为 False 来禁止这个行为。
```
xxxxxxxxxx
push_to_hub( repo_id: str,
        split: Optional[str] = None,
        private: Optional[bool] = False,
        token: Optional[str] = None,
        branch: Optional[str] = None,
        max_shard_size: Optional[Union[int, str]] = None,
        shard_size: Optional[int] = "deprecated",
        embed_external_files: bool = True,
    )
```
  参数：
  - repo_id：一个字符串，指定 repository ID（推动的目的地），例如 "<organization>/<dataset_id>" 。
  - split：一个字符串，指定提供给数据集的 split name，默认为 self.split 。
  - private：一个布尔值，指定是否设置 dataset repository 为私有的。
  - token：一个字符串，指定用于 Hugging Face Hub 的 authentication token 。如果未指定，则使用 huggingface-cli 登录时在本地保存的 token 。如果未指定且用户也没有登录，则抛出异常。
  - branch：一个字符串，指定数据集要推送到哪个分支。默认为你的 repository 的默认分支（通常为 "main" 分支）。
  - max_shard_size：一个整数或字符串，指定上传到 hub 的数据集分片的最大大小。如果为字符串，则需要提供单位，如 "5MB" 。
  - shard_size：一个整数，被废弃，推荐使用 max_shard_size 。
  - embed_external_files：一个布尔值，指定是否在分片中嵌入 file bytes。具体而言，这将在推送之前为以下类型的字段执行如下操作：
    - Audio/Image：移除本地路径信息，然后再 Parquet 文件中嵌入文件内容。
- save_to_disk(dataset_path: str, fs=None)：保存数据集到目录或 S3FileSystem 。
  参数：
  - dataset_path：一个字符串，指定本地路径或者一个 remote URI 从而指定数据集存放的位置。
  - fs：一个 S3FileSystem，指定数据集存放的位置。和 dataset_path 二选一。
  注意，对于本地的图片数据和音频数据，arrow file 存储的是这些数据的文件路径。如果你希望存储这些数据的内容，那么你需要首先读取它们，然后在 arrow file 中包含它们的内容。
- load_from_disk(dataset_path: str, fs=None, keep_in_memory: Optional[bool] = None) -> Dataset ：从 save_to_disk() 存储的目录中加载数据集。
  参数：
  - keep_in_memory：一个布尔值，指定是否加载数据集到内存。如果为 None，那么数据集根据 datasets.config.IN_MEMORY_MAX_SIZE 非零时才拷贝到内存。
  - 其它参数参考 save_to_disk() 。
  返回一个 Dataset 。
- flatten_indices()：通过展平 indices mapping 来创建并缓存一个新的 Dataset
```
xxxxxxxxxx
flatten_indices(keep_in_memory: bool = False,
        cache_file_name: Optional[str] = None,
        writer_batch_size: Optional[int] = 1000,
        features: Optional[Features] = None,
        disable_nullable: bool = False,
        new_fingerprint: Optional[str] = None,
    ) -> Dataset
```
  参数：参考 map() 。
  返回值：一个新的 Dataset 。
- to_csv()：数据集导出为 csv 文件。
```
xxxxxxxxxx
to_csv(path_or_buf: Union[PathLike, BinaryIO],
        batch_size: Optional[int] = None,
        num_proc: Optional[int] = None,
        **to_csv_kwargs,
    ) -> int
```
  参数：
  - path_or_buf：一个文件路径，或者一个 BinaryIO，指定目标 csv 文件。
  - batch_size：一个整数，指定单次写入的样本数量。默认由 datasets.config.DEFAULT_MAX_BATCH_SIZE 决定。
  - num_proc：一个整数，指定多进程的进程数量。默认不使用多进程。
  - to_csv_kwargs：关键字参数，用于传递给 pandas.DataFrame.to_csv() 。
  返回一个整数，表示已经写了多少个字符或字节。
- to_pandas( batch_size: Optional[int] = None, batched: bool = False) -> Union[pd.DataFrame, Iterator[pd.DataFrame]]：将数据集转换为 pandas.DataFrame。对于较大的数据集，也可以返回一个 generator 。
  参数：
  - batched：一个布尔值，如果为 True 则返回一个 generator （它 yield 批量的样本）。如果为 False 则返回整个数据集。
  - batch_size：参考 to_csv() 。
  返回一个 pandas.DataFrame 或者一个 generator 。
- to_dict(batch_size: Optional[int] = None, batched: bool = False) -> Union[dict, Iterator[dict]]：将数据集转换为 Python 字典。对于较大的数据集，也可以返回一个 generator 。
  参数：参考 to_pandas 。
  返回值一个字典或者一个 generator 。
- to_json()：将数据集导出为 JSON 文件。
```
xxxxxxxxxx
to_json(path_or_buf: Union[PathLike, BinaryIO],
        batch_size: Optional[int] = None,
        num_proc: Optional[int] = None,
        lines: Optional[bool] = True,
        **to_json_kwargs,
    ) -> int 
```
  参数：
  - lines：一个布尔值，指定是否输出 JSON lines 格式。
  - to_json_kwargs：关键字参数，传递给 pandas.DataFrame.to_json() 。
  - 其它参数参考 to_csv() 。
  返回一个整数，表示已经写了多少个字符或字节。
- to_parquet()：将数据集导出为 parquet 文件。
```
xxxxxxxxxx
to_parquet(path_or_buf: Union[PathLike, BinaryIO],
        batch_size: Optional[int] = None,
        num_proc: Optional[int] = None,
        **parquet_writer_kwargs,
    ) -> int 
```
  参数：
  - parquet_writer_kwargs：关键字参数，传递给 pyarrow.parquet.ParquetWriter 。
  - 其它参数参考 to_csv() 。
  返回一个整数，表示已经写了多少个字符或字节。
- to_sql()：导出数据集到 SQL 数据库。
```
xxxxxxxxxx
to_sql(name: str,
        con: Union[str, "sqlalchemy.engine.Connection", "sqlalchemy.engine.Engine", "sqlite3.Connection"],
        batch_size: Optional[int] = None,
        **sql_writer_kwargs,
    ) -> int
```
  参数：
  - name/con：参考 from_sql 。
  - batch_size：参考 to_csv() 。
  - sql_writer_kwargs：关键字参数，传递给 Dataframe.to_sql()。
  返回一个整数，表示已经写入了多少行记录。
- add_faiss_index()：添加一个 dense index （使用 Faiss）来用于快速检索。默认情况下，索引是在指定的列上的向量上完成的。如果要在 GPU 上运行，也可以指定设备。
```
xxxxxxxxxx
add_faiss_index( column: str,
        index_name: Optional[str] = None,
        device: Optional[int] = None,
        string_factory: Optional[str] = None,
        metric_type: Optional[int] = None,
        custom_index: Optional["faiss.Index"] = None,  # noqa: F821
        batch_size: int = 1000,
        train_size: Optional[int] = None,
        faiss_verbose: bool = False,
        dtype=np.float32,
    )
```
  参数：
  - column：一个字符串，指定在哪一列的向量上添加这个 dense index 。
  - index_name ：一个字符串，指定新加的 dense index 的名字。这个名词常被用于 get_nearest_examples() 或 search() 。
  - device：一个整数或者整数列表。如果是正整数，则指定 GPU 的编号；如果是负整数，则表示所有的 GPU 。如果是正整数列表，则表示在指定的一组 GPU 上运行。默认使用 CPU 。
  - string_factory：一个字符串，它被传递给 Faiss 的 index factory 来创建 dense index 。
  - metric_type：一个整数，指定指标的类型。例如，faiss.METRIC_INNER_PRODUCT 或 faiss.METRIC_L2 。
  - custom_index：一个 faiss.Index，指定自定义的 Faiss index 。
  - batch_size：一个整数，指定单词添加多少个 vector 到 FaissIndex 。
  - train_size：一个整数，如果 index 需要训练，那么指定多少个 vector 来训练。
  - faiss_verbose：一个布尔值，开启 faiss 的日志输出。
  - dtype：一个数据类型，指定 dense index 的 numpy array 类型。默认为 np.float32 。
  示例（FAISS 语义检索）：
```
xxxxxxxxxx
from transformers import AutoTokenizer, AutoModel
import torch


######### 加载预训练模型 #########
model_ckpt = "sentence-transformers/multi-qa-mpnet-base-dot-v1"
tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
model = AutoModel.from_pretrained(model_ckpt)


device = torch.device("cuda")
model.to(device) # 移动到 GPU


########## 函数: 获取 batch 样本的 cls emebdding ######
def get_embeddings(text_list): 
    encoded_input = tokenizer(
        text_list, padding=True, truncation=True, return_tensors="pt"
    )
    encoded_input = {k: v.to(device) for k, v in encoded_input.items()}
    model_output = model(**encoded_input)
    return model_output.last_hidden_state[:, 0]


embedding = get_embeddings(comments_dataset["text"][0])
print(embedding.shape)


########### 对数据集增加 cls emebdding 列 #######
embeddings_dataset = comments_dataset.map(
    lambda x: {"embeddings": get_embeddings(x["text"]).detach().cpu().numpy()[0]}
)


########## 对数据集增加 faiss index #########
embeddings_dataset.add_faiss_index(column="embeddings")


######### 获取 query emebdding #######
question = "What is your name?"
question_embedding = get_embeddings([question]).cpu().detach().numpy()
print(question_embedding.shape)


########## 检索 query 最相似的 top-k 样本 ######
scores, samples = embeddings_dataset.get_nearest_examples(
    "embeddings", question_embedding, k=5
)
```
- add_faiss_index_from_external_arrays()：添加一个 dense index （使用 Faiss）来用于快速检索。索引是在 external_arrays 的向量上创建的。如果要在 GPU 上运行，也可以指定设备。
```
xxxxxxxxxx
add_faiss_index_from_external_arrays(external_arrays: np.array,
        index_name: str,
        device: Optional[int] = None,
        string_factory: Optional[str] = None,
        metric_type: Optional[int] = None,
        custom_index: Optional["faiss.Index"] = None,  # noqa: F821
        batch_size: int = 1000,
        train_size: Optional[int] = None,
        faiss_verbose: bool = False,
        dtype=np.float32,
    )
```
  参数：
  - external_arrays：一个 np.array 对象，指定在哪一列（外部的列）的向量上添加这个 dense index 。
  - 其它参数参考 add_faiss_index() 。
- save_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath])：保存 FaissIndex 到磁盘。
  参数：
  - index_name：一个字符串，指定 faiss index 的列名。
  - file：一个字符串，指定序列化之后的 faiss index 所保存的文件的文件名。
- load_faiss_index()：从硬盘加载 FaissIndex 。
```
xxxxxxxxxx
load_faiss_index(index_name: str, 
                 file: typing.Union[str, pathlib.PurePath],
                 device: typing.Union[int, typing.List[int], NoneType] = None )
```
  参数：
  - device： add_faiss_index() 。
  - 其它参数参考 save_faiss_index() 。
- add_elasticsearch_index()：添加一个 text index （使用 ElasticSearch）来用于快速检索。这是原地操作。
```
xxxxxxxxxx
add_elasticsearch_index(column: str,
        index_name: Optional[str] = None,
        host: Optional[str] = None,
        port: Optional[int] = None,
        es_client: Optional["elasticsearch.Elasticsearch"] = None,  # noqa: F821
        es_index_name: Optional[str] = None,
        es_index_config: Optional[dict] = None,
    )
```
  参数：
  - column/index_name ：参考 add_faiss_index() 。
  - host：一个字符串，指定 ElasticSearch 运行的主机，默认为 'localhost' 。
  - port：一个字符串，指定 ElasticSearch 运行的端口号，默认为 '9200' 。
  - es_client：一个 Elasticsearch 对象，如果 host 和 port 都是 None，那么使用这个 elasticsearch client 来创建 text index 。
  - es_index_name：一个字符串，指定被用于创建 text index 的 elasticsearch index name 。
  - es_index_config：一个字典，指定 elasticsearch index 的配置。默认的配置为：
```
xxxxxxxxxx
{
  "settings": {
      "number_of_shards": 1,
      "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}},
   },
   "mappings": {
      "properties": {
          "text": {
              "type": "text",
              "analyzer": "standard",
               "similarity": "BM25"
          },
      }
   },
}
```
- load_elasticsearch_index()：加载已有的 text index （使用 ElasticSearch）用于快速检索。
```
xxxxxxxxxx
load_elasticsearch_index(index_name: str,
        es_index_name: str,
        host: typing.Optional[str] = None,
        port: typing.Optional[int] = None,
        es_client: typing.Optional[ForwardRef('Elasticsearch')] = None,
        es_index_config: typing.Optional[dict] = None )
```
  参数：参考 add_elasticsearch_index() 。
- list_indexes()：列出所有 attached indexes 的列名。
- get_index(index_name: str ) -> BaseIndex：返回指定列上 attached indexes 的列名。
  参数：index_name：一个字符串，指定列名。
- drop_index(index_name: str)：移除指定列上的 index 。
  参数：参考 get_index() 。
- search()：在数据集中寻找与给定 query 最近邻的样本，返回临近度得分。
```
xxxxxxxxxx
search(index_name: str,
       query: typing.Union[str, <built-in function array>],
       k: int = 10 ) ->  scores (List[List[float])
```
  参数：
  - index_name：一个字符串，指定索引的名字。
  - query：一个字符串或一个 np.ndarray，指定 query。如果 index_name 对应于 text index，那么 query 是一个字符串；如果 index_name 是一个 vector index，那么 query 是一个 np.ndarray 。
  - k：一个整数，指定寻找最近邻的多少个。
  返回一组最近邻的样本的近邻分。
- search_batch()：在数据集中寻找与给定的一组 query 最近邻的样本，返回针对每个 query 的临近度得分。
```
xxxxxxxxxx
search_batch(index_name: str,
       queries: typing.Union[typing.List[str], <built-in function array>],
       k: int = 10 ) ->   total_scores (List[List[float])
```
  参数：参考 search() 。
  返回多组最邻近的样本的近邻分，每一组对应一个 query 。
- get_nearest_examples(index_name: str, query: Union[str, np.array], k: int = 10) -> scores (List[float])：类似于 search()。
  参数：参考 search()。
  返回一组最近邻的样本的近邻分。
- get_nearest_examples_batch(index_name: str, queries: typing.Union[typing.List[str], <built-in function array>], k: int = 10) -> total_scores (List[List[float])：参考 search_batch() 。
  参数：参考 search_batch() 。
  返回多组最邻近的样本的近邻分，每一组对应一个 query 。
- prepare_for_task(task: Union[str, TaskTemplate], id: int = 0) -> Dataset ：通过将数据集的 Features 强制类型转换为标准化的列名和列类型（由 dataset.tasks 中描述），从而为给定的 task 来准备数据集。
  仅供一次性使用，因此在强制类型转换之后，所有的 task template 都将从 datasets.DatasetInfo.task_templates 中移除。
  参数：
  - task：一个字符串或者 TaskTemplate，指定为哪个任务准备数据集。
    - 如果是字符串，那么必须为： "text-classification" 或 "question-answering" 。
    - 如果是 TaskTemplate，那么必须是 dataset.tasks 中定义的 task templates 之一。
      目前支持（位于 dataset.tasks 内）:
```
xxxxxxxxxx
AudioClassification,  AutomaticSpeechRecognition, ImageClassification, LanguageModeling, QuestionAnsweringExtractive, Summarization, TextClassification
```
  - id：一个整数，当支持多个相同类型的 task template 时，显式标识 task template 所需的 id 。
  返回一个 Dataset 。
- align_labels_with_mapping(label2id: Dict, label_column: str) -> Dataset：根据输入的 label2id 来对齐数据集的 label ID 和 label name 。注意，对齐的过程中，对 label name 使用小写。
  参数：
  - label2id：一个字典，指定 label name 到 label ID 的映射。
  - label_column：一个字符串，指定数据集的哪一列为 label 列。
  返回值一个 Dataset 。
datasets 的函数：
- datasets.concatenate_datasets()：拼接多个 Dataset 到单个 Dataset。
```
xxxxxxxxxx
concatenate_datasets(
    dsets: List[Dataset],
    info: Optional[DatasetInfo] = None,
    split: Optional[NamedSplit] = None,
    axis: int = 0,
) -> Dataset
```
  参数：
  - dsets：一个 Dataset 的列表，指定多个数据集。
  - info：一个 DatasetInfo ，指定新的 Dataset 的信息，如描述信息等等。
  - axis：一个整数，可以为 0 或 1，表示沿着行拼接（0，从上到下拼接）或者列拼接（1，从左到右拼接）。
- datasets.interleave_datasets()：将几个数据集交错而成一个新的数据集。新的数据集是通过在 source dataset 之间进行交错迭代从而获得样本。
```
xxxxxxxxxx
interleave_datasets(
    datasets: List[DatasetType],
    probabilities: Optional[List[float]] = None,
    seed: Optional[int] = None,
    info: Optional[DatasetInfo] = None,
    split: Optional[NamedSplit] = None,
    stopping_strategy: Optional[str] = "first_exhausted",
) -> DatasetType
```
  参数：
  - datases：一个 Dataset 或 IterableDataset 的列表，指定对哪些数据集进行交错。
  - probabilities：一个浮点数列表。
    - 如果为 None，则表示在每个源数据集之间轮流迭代（即第一个样本来自于第一个源数据集，第二个样本来自于第二个源数据集，...）。
    - 如果不是 None，则每次根据给定的概率随机选择一个源数据集来进行迭代。
  - seed：一个整数，指定随机数种子，用于配合 probabilities 来随机选择一个源数据集。
  - info：一个 DatasetInfo 对象，指定新数据集的信息。
  - split：一个 NamedSplit 对象，指定 dataset split 的名字。
  - stopping_strategy：一个字符串，目前支持两种策略：
    - "first_exhausted "：一旦某个数据集耗尽样本，则停止构建数据集。
    - "all_exhausted"：每个数据集至少被完全迭代过一次，当且仅当所有数据集都被迭代过一次，则停止构建数据集。注意，此时新数据集的规模可能非常大。如果 probabilities = None，那么新数据集的规模为 max_length_datasets*num_dataset ；如果 probabilities != None，并且如果某个数据集的访问概率非常低，那么新数据集可能包含非常非常多的样本。
  返回一个 Dataset （当 datases 是 Dataset 列表时）或 IterableDataset （当 datases 是 IterableDataset 列表时）。
- datasets.enable_caching()：启用缓存。
  当对数据集应用 transform 时，数据被存储在缓存文件中。缓存机制允许重新加载已经计算过的、现有的缓存文件。重新加载数据集是可能的，因为缓存文件是使用数据集指纹 dataset fingerprint 命名的，指纹在每次 transform 后都会更新。
  如果禁用缓存，那么当对数据集应用 transform 时，Datasets library 将不再重新加载缓存的数据文件。具体而言，如果禁用缓存：
  - 缓存文件总是被重新创建。
  - 缓存文件被写入临时目录，当会话关闭时，该目录将被删除。
  - 使用随机哈希而不是数据集指纹来命名缓存文件。
  - 使用 datasets.Dataset.save_to_disk() 来保存一个 transformerd dataset 或者在会话关闭时删除 transformerd dataset 。
  - 缓存不会影响 datasets.load_dataset() 。如果要从头重新生成数据集，应该使用 datasets.load_dataset() 中的 download_mode 参数。
- datasets.disable_caching()：禁用缓存。
- datasets.is_caching_enabled() -> bool：返回缓存是否被启用。

class DatasetDict：继承自 Python dict，包含 Dataset 的字典，其中键为 split name （如 'train', 'test' 等等）。它也包含一些 dataset transform 方法，如 map/filter，作用到每个 split 上。

属性：

data -> Dict[str, Table]：一个字典，返回每个 split 的 Apache Arrow table 。
cache_files -> Dict[str, Dict]：一个字典，返回每个 split 的缓存文件。
num_columns -> Dict[str, int]：一个字典，返回每个 split 的列数。
num_rows -> Dict[str, int]：一个字典，返回每个 split 的行数。
column_names -> Dict[str, List[str]]：一个字典，返回每个 split 的列名。
shape -> Dict[str, Tuple[int]] ：一个字典，返回每个 split 的形状（列数，行数）。

方法：参考 Dataset 的对应方法，其中 DatasetDict 的方法会应用到字典中的每个 Dataset 上，并且返回 DatasetDict 而不是Dataset 。


xxxxxxxxxx
unique(column: str) -> Dict[str, List]
cleanup_cache_files() -> Dict[str, int]
map( function: Optional[Callable] = None,
        with_indices: bool = False,
        with_rank: bool = False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: Optional[int] = 1000,
        drop_last_batch: bool = False,
        remove_columns: Optional[Union[str, List[str]]] = None,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        cache_file_names: Optional[Dict[str, Optional[str]]] = None,
        writer_batch_size: Optional[int] = 1000,
        features: Optional[Features] = None,
        disable_nullable: bool = False,
        fn_kwargs: Optional[dict] = None,
        num_proc: Optional[int] = None,
        desc: Optional[str] = None,
    ) -> DatasetDict
filter( function,
        with_indices=False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: Optional[int] = 1000,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        cache_file_names: Optional[Dict[str, Optional[str]]] = None,
        writer_batch_size: Optional[int] = 1000,
        fn_kwargs: Optional[dict] = None,
        num_proc: Optional[int] = None,
        desc: Optional[str] = None,
    ) -> DatasetDict
sort( column: str,
        reverse: bool = False,
        kind: str = None,
        null_placement: str = "last",
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        indices_cache_file_names: Optional[Dict[str, Optional[str]]] = None,
        writer_batch_size: Optional[int] = 1000,
    ) -> DatasetDict
 shuffle( seeds: Optional[Union[int, Dict[str, Optional[int]]]] = None,
        seed: Optional[int] = None,
        generators: Optional[Dict[str, np.random.Generator]] = None,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        indices_cache_file_names: Optional[Dict[str, Optional[str]]] = None,
        writer_batch_size: Optional[int] = 1000,
    ) -> DatasetDict
set_format(type: Optional[str] = None,
        columns: Optional[List] = None,
        output_all_columns: bool = False,
        **format_kwargs,
    )
reset_format()
formatted_as( type: Optional[str] = None,
        columns: Optional[List] = None,
        output_all_columns: bool = False,
        **format_kwargs,
    )
with_format( type: Optional[str] = None,
        columns: Optional[List] = None,
        output_all_columns: bool = False,
        **format_kwargs,
    ) -> DatasetDict
with_transform(transform: Optional[Callable],
        columns: Optional[List] = None,
        output_all_columns: bool = False,
    ) -> DatasetDict
flatten(max_depth=16) -> DatasetDict
cast(features: Features) -> DatasetDict
cast_column(column: str, feature) -> DatasetDict
remove_columns(column_names: Union[str, List[str]]) -> DatasetDict
rename_column(original_column_name: str, new_column_name: str) -> DatasetDict
rename_columns(column_mapping: Dict[str, str]) -> DatasetDict
class_encode_column(column: str, include_nulls: bool = False) -> DatasetDict
push_to_hub( repo_id,
        private: Optional[bool] = False,
        token: Optional[str] = None,
        branch: Optional[None] = None,
        max_shard_size: Optional[Union[int, str]] = None,
        shard_size: Optional[int] = "deprecated",
        embed_external_files: bool = True,
    )
save_to_disk(dataset_dict_path: str, fs=None)
load_from_disk(dataset_dict_path: str, fs=None, 
               keep_in_memory: Optional[bool] = None) -> DatasetDict
from_csv(path_or_paths: Dict[str, PathLike],
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        **kwargs,
    ) -> DatasetDict
from_json( path_or_paths: Dict[str, PathLike],
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        **kwargs,
    ) -> DatasetDict
from_parquet(path_or_paths: Dict[str, PathLike],
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        columns: Optional[List[str]] = None,
        **kwargs,
    ) -> DatasetDict
from_text( path_or_paths: Dict[str, PathLike],
        features: Optional[Features] = None,
        cache_dir: str = None,
        keep_in_memory: bool = False,
        **kwargs,
    ) -> DatasetDict
prepare_for_task(task: Union[str, TaskTemplate], id: int = 0) -> DatasetDict

class datasets.IterableDataset：基于 python generator 实现的迭代式数据集。


xxxxxxxxxx
class IterableDataset(
      ex_iterable: _BaseExamplesIterable,
        info: Optional[DatasetInfo] = None,
        split: Optional[NamedSplit] = None,
        format_type: Optional[str] = None,
        shuffling: Optional[ShufflingConfig] = None,
        token_per_repo_id: Optional[Dict[str, Union[str, bool, None]]] = None,
)

参数：文档未给出，同时源码也未给出。

属性：参考 Dataset 。


xxxxxxxxxx
info, split, builder_name, citation, config_name, dataset_size, description, download_checksums, download_size, features, homepage, license, size_in_bytes, supervised_keys, version

方法：

skip(n) -> IterableDataset ：创建一个新的 IterableDataset ，它跳过了旧 IterableDataset 的前 n 的元素。
参数：n ：一个整数，指定跳过多少个元素。
返回一个新的 IterableDataset 。
take(n) -> IterableDataset ：创建一个新的 IterableDataset ，它仅包含旧 IterableDataset 的前 n 的元素。
参数：n ：一个整数，指定包含多少个元素。
返回一个新的 IterableDataset 。

下列方法参考 Dataset，其中 IterableDataset 的方法返回 IterableDataset 而不是Dataset 。


xxxxxxxxxx
from_generator(
        generator: Callable,
        features: Optional[Features] = None,
        gen_kwargs: Optional[dict] = None,
    ) -> IterableDataset
remove_columns(column_names: Union[str, List[str]]) -> IterableDataset
cast_column(column: str, feature: FeatureType) -> IterableDataset
cast(features: Features) -> IterableDataset
__iter__()
map( function: Optional[Callable] = None,
        with_indices: bool = False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: int = 1000,
        drop_last_batch: bool = False,
        remove_columns: Optional[Union[str, List[str]]] = None,
        fn_kwargs: Optional[dict] = None,
    ) -> IterableDataset
rename_column(original_column_name: str, new_column_name: str) -> IterableDataset
 filter(function: Optional[Callable] = None,
        with_indices=False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: Optional[int] = 1000,
    ) -> IterableDataset
shuffle(seed=None, generator: Optional[np.random.Generator] = None, 
        buffer_size: int = 1000
    ) -> IterableDataset

class datasets.IterableDatasetDict：继承自 Python dict，包含 IterableDataset 的字典，其中键为 split name （如 'train', 'test' 等等）。它也包含一些 dataset transform 方法，如 map/filter，作用到每个 split 上。

方法：参考 DatasetDict 的对应方法，其中 IterableDatasetDict 的方法返回 IterableDatasetDict 而不是DatasetDict 。


xxxxxxxxxx
map( function: Optional[Callable] = None,
        with_indices: bool = False,
        with_rank: bool = False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: Optional[int] = 1000,
        drop_last_batch: bool = False,
        remove_columns: Optional[Union[str, List[str]]] = None,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        cache_file_names: Optional[Dict[str, Optional[str]]] = None,
        writer_batch_size: Optional[int] = 1000,
        features: Optional[Features] = None,
        disable_nullable: bool = False,
        fn_kwargs: Optional[dict] = None,
        num_proc: Optional[int] = None,
        desc: Optional[str] = None,
    ) -> IterableDatasetDict
filter( function,
        with_indices=False,
        input_columns: Optional[Union[str, List[str]]] = None,
        batched: bool = False,
        batch_size: Optional[int] = 1000,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        cache_file_names: Optional[Dict[str, Optional[str]]] = None,
        writer_batch_size: Optional[int] = 1000,
        fn_kwargs: Optional[dict] = None,
        num_proc: Optional[int] = None,
        desc: Optional[str] = None,
    ) -> IterableDatasetDict
 shuffle( seeds: Optional[Union[int, Dict[str, Optional[int]]]] = None,
        seed: Optional[int] = None,
        generators: Optional[Dict[str, np.random.Generator]] = None,
        keep_in_memory: bool = False,
        load_from_cache_file: bool = True,
        indices_cache_file_names: Optional[Dict[str, Optional[str]]] = None,
        writer_batch_size: Optional[int] = 1000,
    ) -> IterableDatasetDict
with_format( type: Optional[str] = None,
        columns: Optional[List] = None,
        output_all_columns: bool = False,
        **format_kwargs,
    ) -> IterableDatasetDict
cast(features: Features) -> IterableDatasetDict
cast_column(column: str, feature) -> IterableDatasetDict
remove_columns(column_names: Union[str, List[str]]) -> IterableDatasetDict
rename_column(original_column_name: str, new_column_name: str) -> IterableDatasetDict
rename_columns(column_mapping: Dict[str, str]) -> IterableDatasetDict

3.3 Features

class datasets.Features(*args, **kwargs)：一个特殊的字典，定义了数据集的内部结构。
Features 通过 dict[str, FieldType] 类型的字典来实例化，其中键是列名、值为该列的类型。FieldType 可以为：
- datasets.Value：该特征指定了 single typed value，如 int64 或 string 。
- datasets.ClassLabel：该特征指定了一个字段，该字段包含一组预定义的类别，这些类别关联了一些整数标签（数据集中以整数标签来存储）。
- 一个 python 字典：该特征指定了一个嵌套的字段，其中将 sub-field 名称映射到 sub-field 类型。
- 一个 python 列表或 datasets.Sequence：该特征指定了一个字段，该字段包含对象的一个列表。 python 列表或 datasets.Sequence 的每个元素都是 single sub-feature 。
- 一个 Array2D/Array3D/Array4D/Array5D：该特征是多维数组。
- 一个 Audio：该特征存储音频文件的绝对路径，或者存储音频文件的相对路径（ "path" 键）映射到音频内容（"bytes" 键）的字典。
- 一个 Image：该特征存储图片文件的绝对路径、或者 np.ndarray 对象、或者 PIL.Image.Image 对象，或者存储图片文件的相对路径（ "path" 键）映射到图片内容（"bytes" 键）的字典。
- Translation/TranslationVariableLanguages：仅用于机器翻译。
方法：
- copy() -> Features：创建当前 Features 的 deep copy 。
- decode_batch(batch: dict[str, list[Any]]) -> dict[str, list[Any]]：对一个 batch 的数据根据当前的特征格式来解码。
  参数：batch：一个字典，表示一个 batch 的数据。
  返回解码后的数据。
- decode_column(column: list[Any], column_name: str) -> list[Any]：对一列数据根据当前的特征格式来解码。
  参数：
  - column：一个列表，包含一列数据。
  - column_name：一个字符串，表示列名。
  返回解码后的数据。
- decode_example(example: dict[str, Any], token_per_repo_id: Optional[Dict[str, Union[str, bool, None]]] = None) -> dict[str, Any]：根据当前的特征格式来解码一个样本。
  参数：
  - example：一个字典，表示数据集的一行（代表一个样本）。
  - token_per_repo_id：一个字典，为了从 Hub 上的私有 repository 中访问和解码音频文件、图像文件，可以传递一个字典 repo_id (str) -> token (bool or str) 。
  返回解码后的样本。
- encode_batch(batch: dict[str, list[Any]]) -> dict[str, list[Any]]：编码 batch 样本到 Arrow 的格式。
  参数：batch：一个 batch 的样本。
  返回编码后的 batch 的样本。
- encode_example(example: dict[str, Any]) -> dict[str, Any]：编码单个样本到 Arrow 的格式。
  参数：example：单个样本。
  返回编码后的样本。
- flatten(max_depth=16) -> Features：特征展平，返回展平后的特征。
  每个 dictionary column 被移除，并代之以它包含的所有 subfields。新的字段名字由原始的里恶名和 subfield name 拼接而成，如 <original>.<subfield> 。如果有多层嵌套，那么为 <original>.<subfield>.<subsubfield> 。
  参数：max_depth：一个整数，指定最多展平多少层。
- from_arrow_schema( pa_schema: pyarrow.Schema) -> Features ：从 Arrow Schema 构建 Features 。
- from_dict(dic: dict[str, Any]) -> Features：从字典中构建 Features 。我们使用 "_type" 键来推断 feature FieldType 的 dataclass name 。
- reorder_fields_as(other: Features) -> Features ：重新排列当前 Features 的字段，从而匹配 other Features 的字段顺序。
  字段的顺序很重要，因为它关系到底层的 arrow data 。
示例：
```
xxxxxxxxxx
from datasets import Features, Sequence, Value
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 # 字段的顺序很重要


f1.reorder_fields_as(f2)
assert f1.reorder_fields_as(f2).type == f2.type
```
class datasets.Sequence( feature: typing.Any, length: int = -1, id: typing.Optional[str] = None) ：根据单个类型、或者类型的字典来构建 feature 的一个列表。
参数：
- feature：单个类型、或者类型的字典的一个列表。
- length：一个整数，指定 sequence 的长度。
示例：
```
xxxxxxxxxx
from datasets import Features, Sequence, Value, ClassLabel
eatures = Features({
  'post': Sequence(feature={
      'text': Value(dtype='string'), 
      'upvotes': Value(dtype='int32'), 
      'label': ClassLabel(num_classes=2, names=['hot', 'cold'])
    })
})
```
class datasets.ClassLabel：用于整数类别标签的 feature type 。
```
xxxxxxxxxx
class datasets.ClassLabel(
    num_classes: dataclasses.InitVar[typing.Optional[int]] = None,
    names: typing.List[str] = None,
    names_file: dataclasses.InitVar[typing.Optional[str]] = None,
    id: typing.Optional[str] = None 
)
```
参数：
- num_classes：一个整数，指定类别的数量。所有的标签取值必须小于 num_classes 。
- names：一个字符串列表，指定整数类别的类别名字，这些字符串的顺序很重要，对应于对应的整数标签。
- names_file：一个字符串，存储类别名字，每行一个。
底层的 label 存储为整数。你可以使用负的整数代表 unknown/missing 的 label 。
方法：
- cast_storage( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray]) -> pa.Int64Array：将一个 Arrow array 强制类型转换为 ClassLabel arrow storage 类型。只有 pa.string() 和 pa.int() 这两种类型能够执行这种强制类型转换。
  参数：
  - storage：一个 pa.StringArray 或 pa.IntegerArray 类型，表示要被强制类型转换的 PyArrow array 。
  返回值一个 pa.Int64Array 。
- int2str( values: typing.Union[int, collections.abc.Iterable] )：将整数转换为 class name 字符串。如果有负的整数，则抛出异常。
  参数：values：一个整数或整数的可迭代对象，表示待转换的整数。
  返回值一个字符串或字符串的可迭代对象，表示 class name 。
- str2int(values: typing.Union[str, collections.abc.Iterable]) ：将 class name 字符串转换为整数。
  参数：values：一个字符串或字符串的可迭代对象，表示待转化的 class name 。
  返回一个整数或整数的可迭代对象，表示 class label 。
示例：
```
xxxxxxxxxx
from datasets import Features
eatures = Features({'label': ClassLabel(num_classes=3, names=['bad', 'ok', 'good'])})
```

class dataset.Value(dtype: str, id: typing.Optional[str] = None ) ：值类型。可以为如下类型：


xxxxxxxxxx
null bool int8 int16 int32 int64 uint8 uint16 uint32 uint64 float16 float32 (alias float) float64 (alias 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

参数：dtype：一个字符串，表示具体的类型。如 Value(dtype='int32') 。

示例：


xxxxxxxxxx
from datasets import Features
features = Features({'stars': Value(dtype='int32')})

class datasets.Translation(languages: typing.List[str], id: typing.Optional[str] = None )：用于翻译的 FeatureConnector ，其中翻译的每个样本包含固定的语言实例。
参数：languages：一个字符串列表，表示样本包含的语言。
方法：
- flatten() ：将 Translation feature 展平到一个字典中。
Translation 特征的输入输出：
- 输入：每个样本对应一个字典，该字典将 language code 字符串映射到 translation 字符串。
- 输出：一个字典，该字典将 language code 字符串映射到以 Text 特征的 translation 。
示例：
```
xxxxxxxxxx
datasets.features.Translation(languages=['en', 'fr', 'de'])
# 样本生成期间:
yield {
        'en': 'the cat',
        'fr': 'le chat',
        'de': 'die katze'
}
```
class datasets.TranslationVariableLanguages：用于翻译的 FeatureConnector ，其中翻译的每个样本包含可变的语言实例。
```
xxxxxxxxxx
class datasets.TranslationVariableLanguages(languages: typing.Optional[typing.List] = None,
                                            num_languages: typing.Optional[int] = None,
                                            id: typing.Optional[str] = None 
)
```
参数：
- languages：一个字符串列表，表示样本包含的语言。
- num_languages：一个整数，表示最大的实例数量。
方法：
- flatten() ：将 TranslationVariableLanguages feature 展平到一个字典中。
TranslationVariableLanguages 特征的输入输出：
- 输入：每个样本对应一个字典，该字典将 language code 字符串映射到一个或多个 translation 字符串。
- 输出：一个字典，"language" 键对应了一个可变长度的一维张量（升序排列），代表 language code ；"translation" 键对应了一个可变长度的一维张量（与 language 张量对齐且升序排列），代表翻译文本。
示例：
```
xxxxxxxxxx
datasets.features.TranslationVariableLanguages(languages=['en', 'fr', 'de'])
# 样本生成期间:
yield {
        'en': 'the cat',
        'fr': ['le chat', 'la chatte,']
        'de': 'die katze'
}
# 返回
{
        'language': ['en', 'de', 'fr', 'fr'],
        'translation': ['the cat', 'die katze', 'la chatte', 'le chat'],
}
```

class datasets.Array2D/Array3D/Array4D/Array5D：代表 2D/3D/4D/5D 的数组。


xxxxxxxxxx
class datasets.Array2D(shape: tuple， dtype: str， id: typing.Optional[str] = None)
class datasets.Array3D(shape: tuple， dtype: str， id: typing.Optional[str] = None)
class datasets.Array4D(shape: tuple， dtype: str， id: typing.Optional[str] = None)
class datasets.Array5D(shape: tuple， dtype: str， id: typing.Optional[str] = None)

参数：

shape：一个元组，代表数组每个维度的大小。
dtype：一个字符串，代表数组元素的类型。

示例：


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

class datasets.Audio：音频特征，用于从音频文件中抽取音频数据。
```
xxxxxxxxxx
class datasets.Audio(sampling_rate: typing.Optional[int] = None, mono: bool = True, decode: bool = True, id: typing.Optional[str] = None )
```
参数：
- sampling_rate：一个整数，指定采样率。如果为 None，则使用负的采样率。
- mono：一个布尔值，指定是否通过跨通道的平均采样从而将音频信号转换为单声道。
- decode：一个布尔值，指定是否解码音频数据。如果为 False，则以格式 {"path": audio_path, "bytes": audio_bytes} 的格式返回底层的字典。
方法：
- cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray] ) -> pa.StructArray：将一个 Arrow array 强制类型转换为 Audio arrow storage 类型。可以强制类型转换的 Arrow array 类型包括：pa.string() （它必须包含 "path" 数据）、pa.struct({"bytes": pa.binary()}) 、pa.struct({"path": pa.string()})、pa.struct({"bytes": pa.binary(), "path": pa.string()}) （顺序不重要）。
- decode_example( value: dict, token_per_repo_id: typing.Union[typing.Dict[str, typing.Union[str, bool, NoneType]], NoneType] = None) ：解码音频文件到音频数据。
  参数：
  - value：一个字典，包含两个 key："path" ，指定音频文件的相对路径；"bytes"：音频文件的字节。
  - token_per_repo_id：个字典，为了从 Hub 上的私有 repository 中访问和解码音频文件、图像文件，可以传递一个字典 repo_id (str) -> token (bool or str) 。
- encode_example( value: typing.Union[str, dict] ) -> dict：编码样本到一个字典，用于 Arrow 格式。
  参数：
  - value：一个字符串或字典，作为 Audio 特征的 input 。
- embed_storage(storage: StructArray, drop_paths: bool = True ) -> pa.StructArray ：将音频文件嵌入到 Arrow array 。
  参数：
  - storage：一个 pa.StructArray，指定被嵌入的 PyArrow 。
  - drop_paths：一个布尔值，指定是否将 path 设为 None 。
  返回一个 Audio arrow storage 类型的 Array，格式为 pa.struct({"bytes" : pa.binary(), "path" : pa.string()}) 。
- flatten()：展平当前特征到一个字典。
Audio 特征的输入和输出：
- 输入：可以为：
  - 一个字符串：表示音频文件的绝对路径。
  - 一个字典，包含： "path" 键，给出音频文件相对于 archive 文件的相对路径；"bytes" 键，给出音频文件的字节内容。
  - 一个字典，包含："path" 键，给出音频文件相对于 archive 文件的相对路径；"array" 键，给出包含音频样本的数组；"sampling_rate" 键，给出一个整数，对应于音频样本的采样率。
示例：
```
xxxxxxxxxx
from datasets import load_dataset, Audio
ds = load_dataset("PolyAI/minds14", name="en-US", split="train")
ds[0]["audio"]
```
class datasets.Image(decode: bool = True, id: typing.Optional[str] = None )：图片特征。
参数：
- decode：一个布尔值，指定是否解码图片数据。如果为 False，则以格式 {"path": image_path, "bytes": image_bytes} 的格式返回底层的字典。
方法：
- cast_storage( storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray]) -> pa.StructArray：将一个 Arrow array 强制类型转换到 Image arrow storage 类型。可以强制类型转换的 Arrow array 类型包括：pa.string() （它必须包含 "path" 数据）、pa.struct({"bytes": pa.binary()}) 、pa.struct({"path": pa.string()})、pa.struct({"bytes": pa.binary(), "path": pa.string()}) （顺序不重要）、pa.list(*) （必须包含 image array data）。
  参数：参考 datasets.Audio.cast_storage() 。
- decode_example(value: dict, token_per_repo_id = None ) ：参考 datasets.Audio.decode_example() 。
- embed_storage(storage: StructArray, drop_paths: bool = True) -> pa.StructArray：参考 datasets.Audio.embed_storage() 。
- encode_example( value: typing.Union[str, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')]) ：参考 datasets.Audio.encode_example() 。
- flattern()：参考 datasets.Audio.flattern() 。
Image 特征的输入和输出：
- 输入：可以为：
  - 一个字符串：表示图片文件的绝对路径。
  - 一个字典，包含： "path" 键，给出图片文件相对于 archive 文件的相对路径；"bytes" 键，给出图片文件的字节内容。
  - 一个 np.ndarray：代表一张图片的 numpy array 。
  - 一个 PIL.Image：一个 PIL image 对象。
示例：
```
xxxxxxxxxx
from datasets import load_dataset, Image
ds = load_dataset("beans", split="train")
ds.features["image"]
```

3.4 DatasetBuilder

class datasets.DatasetBuilder：所有数据集的抽象基类。
```
xxxxxxxxxx
class datasets.DatasetBuilder(cache_dir: typing.Optional[str] = None,
     config_name: typing.Optional[str] = None,
     hash: typing.Optional[str] = None,
     base_path: typing.Optional[str] = None,
     info: typing.Optional[datasets.info.DatasetInfo] = None,
     features: typing.Optional[datasets.features.features.Features] = None,
     use_auth_token: typing.Union[str, bool, NoneType] = None,
     repo_id: typing.Optional[str] = None,
     data_files: typing.Union[str, list, dict, datasets.data_files.DataFilesDict, NoneType] = None,
     data_dir: typing.Optional[str] = None,
     name = 'deprecated',
     **config_kwargs
)
```
参数：
- cache_dir：一个字符串，指定缓存数据的位置，默认为 "~/.cache/huggingface/datasets" 。
- config_name：一个字符串，指定数据集配置的名字。不同的配置拥有不同的子目录和版本。如果未提供，则使用默认的配置（如果有的话）。
- hash：一个字符串，指定数据集代码的哈希，用于更新缓存目录。
- base_path：一个字符串，指定一个那个目录作为下载文件的 base 目录。
- features：一个 Features 对象，制定数据集的 Features 。
- use_auth_token ：一个字符串或者布尔值，用于访问 Datasets Hub。如果为 True，则从 ~/.huggingface" 获取 token；如果为字符串，则直接指定 token 。
- repo_id：一个字符串，指定 dataset repository 的 ID 。
- data_files：一个字符串或者序列或者映射，指定源数据文件的路径。
- data_dir：一个字符串，指定包含源数据文件的目录的路径。如果 data_files 未提供，那么使用 os.path.join(data_dir, '**') 。
- name：一个字符串，指定数据集的配置名（被废弃，推荐用 config_name ）。
- config_kwargs：关键字参数，传递给对应的 builder 配置类。
DatasetBuilder 有三个主要的方法：
- info() ：对数据集进行说明，包括特征名字、特征类型、数据形状、版本、split 等等。
- download_and_prepare()：下载源数据并写入磁盘。
```
xxxxxxxxxx
download_and_prepare(output_dir: typing.Optional[str] = None,
   download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None,
   download_mode: typing.Optional[datasets.download.download_manager.DownloadMode] = None,
   ignore_verifications: bool = False,
   try_from_hf_gcs: bool = True,
   dl_manager: typing.Optional[datasets.download.download_manager.DownloadManager] = None,
   base_path: typing.Optional[str] = None,
   use_auth_token: typing.Union[str, bool, NoneType] = None,
   file_format: str = 'arrow',
   max_shard_size: typing.Union[int, str, NoneType] = None,
   num_proc: typing.Optional[int] = None,
   storage_options: typing.Optional[dict] = None,
   **download_and_prepare_kwargs 
)
```
  参数：
  - output_dir ：一个字符串，指定数据集的输出目录。默认为 "~/.cache/huggingface/datasets" 。
  - download_config：一个 DownloadConfig对象，指定下载配置。
  - download_mode：一个 DownloadMode 对象，指定下载/生成的模式。默认为 REUSE_DATASET_IF_EXISTS 。
  - ignore_verifications：一个布尔值，指定是否忽略对下载的数据进行校验。
  - try_from_hf_gcs：一个布尔值，指定是否从 Hf google cloud storage 下载 prepared dataset 。
  - dl_manager：一个 DownloadManager 对象，指定使用哪个下载管理器。
  - base_path：一个字符串，指定用哪个目录作为下载文件的 base 目录。
  - use_auth_token：一个字符串，参考 DatasetBuilder 构造方法。
  - file_format：一个字符串，指定数据文件的格式。支持 "arrow" 和 "parquet" 。如果是 "parquet" ，那么图片数据和音频数据将被嵌入到 Parquet 文件中，而不是指向本地文件的路径。
  - max_shard_size：一个字符串或整数，指定每个分片所写入的最大字节数。仅支持对 "parquet" 格式使用默认的 "500MB" 的大小。这个 size 是基于未压缩的数据大小，因此对于 Parquet compression，分片文件可能要小于 max_shard_size 。
  - num_proc：一个整数，指定用于下载和生成本地数据集的进程数。默认不使用多进程。
  - storage_options：一个字典，key-value pair ，被传入缓存文件系统。
  - download_and_prepare_kwargs：额外的关键字参数。
- as_dataset(split: typing.Optional[datasets.splits.Split] = None, run_post_process = True, ignore_verifications = False, in_memory = False )：生成一个数据集。
  参数：
  - split：一个 Split，指定返回数据的哪个子集。
  - run_post_process：一个布尔值，指定是否对数据集运行后处理。
  - ignore_verifications：一个布尔值，指定是否忽略对下载后/处理后的数据集的信息进行校验。
  - in_memory：一个布尔值，指定是否将数据拷贝到内存中。

class datasets.BuilderConfig：Builder 配置的基类。


xxxxxxxxxx
class datasets.BuilderConfig(name: str = 'default', 
    version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
    data_dir: typing.Optional[str] = None,
    data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
    description: typing.Optional[str] = None
)

class datasets.DownloadManager：下载管理器。


xxxxxxxxxx
class class datasets.DownloadManager(dataset_name: typing.Optional[str] = None,
    data_dir: typing.Optional[str] = None,
    download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None,
    base_path: typing.Optional[str] = None,
    record_checksums = True
)

class datasets.StreamingDownloadManager：流式下载管理器。


xxxxxxxxxx
class datasets.StreamingDownloadManager(dataset_name: typing.Optional[str] = None,
    data_dir: typing.Optional[str] = None,
    download_config: typing.Optional[datasets.download.download_config.DownloadConfig] = None,
    base_path: typing.Optional[str] = None
)

class datasets.DownloadConfig：下载配置


xxxxxxxxxx
class datasets.DownloadConfig(cache_dir: typing.Union[str, pathlib.Path, NoneType] = None, 
    force_download: bool = False,
    resume_download: bool = False,
    local_files_only: bool = False,
    proxies: typing.Optional[typing.Dict] = None,
    user_agent: typing.Optional[str] = None,
    extract_compressed_file: bool = False,
    force_extract: bool = False,
    delete_extracted: bool = False,
    use_etag: bool = True,
    num_proc: typing.Optional[int] = None,
    max_retries: int = 1,
    use_auth_token: typing.Union[bool, str, NoneType] = None,
    ignore_url_params: bool = False,
    download_desc: typing.Optional[str] = None
)

class class datasets.DownloadMode：下载模式的枚举类。包括：


xxxxxxxxxx
REUSE_DATASET_IF_EXISTS # 默认行为，重用下载的数据，重用数据集
REUSE_CACHE_IF_EXISTS   # 重用下载的数据，不重用数据集
FORCE_REDOWNLOAD        # 既不重用下载的数据，也不重用数据集

class datasets.Split：数据集拆分的枚举类。包括：


xxxxxxxxxx
TRAIN      # 训练集
VALIDATION # 验证集
TEST       # 测试集
ALL        # 整个数据集

3.5 加载数据集

数据集加载：
- datasets.list_datasets(with_community_datasets = True, with_details = False )：列出 Hugging Face Hub 上所有的可用数据集。
  参数：
  - with_community_datasets：一个布尔值，指定是否包含社区提供的数据集。
  - with_details：一个布尔值，指定是否返回完整的细节而不是简称。
- datasets.load_dataset()：从 Hugging Face Hub 或本地加载数据集。
  注意，也可能下载的是 dataset script，然后该脚本从任意其他地方下载数据集。
```
xxxxxxxxxx
load_dataset(
    path: str,
    name: Optional[str] = None,
    data_dir: Optional[str] = None,
    data_files: Optional[Union[str, Sequence[str], Mapping[str, Union[str, Sequence[str]]]]] = None,
    split: Optional[Union[str, Split]] = None,
    cache_dir: Optional[str] = None,
    features: Optional[Features] = None,
    download_config: Optional[DownloadConfig] = None,
    download_mode: Optional[DownloadMode] = None,
    ignore_verifications: bool = False,
    keep_in_memory: Optional[bool] = None,
    save_infos: bool = False,
    revision: Optional[Union[str, Version]] = None,
    use_auth_token: Optional[Union[bool, str]] = None,
    task: Optional[Union[str, TaskTemplate]] = None,
    streaming: bool = False,
    num_proc: int = None,
    **config_kwargs,
) -> Union[DatasetDict, Dataset, IterableDatasetDict, IterableDataset]
```
  参数：
  - path：一个字符串，指定数据集的路径或名字。
    对于本地数据集：
    - 如果 path 是一个本地目录（仅包含数据文件），那么 Datasets 基于目录的内容加载一个通用的 dataset builder （如，csv, json, text）。
    - 如果 path 是一个本地的 dataset script 或包含一个本地的 dataset script ，那么从这个 dataset script 加载 dataset builder 。
    对于 Hugging Face Hub 数据集：
    - 如果 path 是一个 dataset repository（仅包含数据文件），那么 Datasets 基于 repository 的内容加载一个通用的 dataset builder （如，csv, json, text）。
    - 如果 path 是一个带有 dataset script 的 dataset repository，那么从这个 dataset script 加载 dataset builder 。
  - name：一个字符串，指定数据集配置的名字。
  - data_dir：一个字符串，指定数据集配置的 data_dir 。
  - data_files：一个字符串或字符串序列或字符串映射，指定源数据文件的路径。
  - split：一个字符串或 Split，指定加载数据集的哪个部分。如果为 None，则返回一个字典，该字典包含所有的 split 。
  - cache_dir：一个字符串，指定读写数据的缓存位置，默认为 "~/.cache/huggingface/datasets" 。
  - features：一个 Features，指定数据集的特征类型。
  - download_config：一个 DownloadConfig，指定下载配置。
  - download_mode：一个 DownloadMode，指定下载模式。
  - ignore_verifications：一个布尔值，指定是否验证下载/处理的数据集。
  - keep_in_memory：一个布尔值，指定是否拷贝数据集到内存中。
  - save_infos：一个布尔值，指定是否保存数据集信息（如 checksums/size/splits/... ）。
  - revision：一个字符串或 Version，指定加载 dataser script 的哪个版本。默认为 "main" 分支。
  - use_auth_token：一个字符串或布尔值，参考 DatasetBuilder 构造方法。
  - task：一个字符串，指定该数据集需要为哪个任务进行 prepare 从而训练和评估。将会对数据集的 Features 强制类型转换，从而匹配该任务的标准列名和列类型。
  - streaming：一个布尔值。如果为 True，则不会下载数据文件，而是流式地迭代该数据集。仅 txt, csv, jsonl 文件支持流式下载，而 Json 文件需要完整地下载。
  - num_proc：一个整数，指定下载和生成数据集的进程数。默认不使用多进程。
  - config_kwargs：关键字参数，被传递给 BuilderConfig 和 DatasetBuilder 。
  如果 streaming = False，返回一个 Dataset 或 DatasetDict。
  - 如果 split 不是 None，则返回 Dataset。
  - 如果 split = None，则返回 DatasetDict，它包含每个 split 。
  或者，如果 streaming = True，则返回一个 IterableDataset 或 IterableDatasetDict 。
- datasets.load_from_disk(dataset_path: str, fs=None, keep_in_memory: Optional[bool] = None) -> Union[Dataset, DatasetDict]：从磁盘上加载数据集，该数据集之前通过 Dataset.save_to_disk() 写入到磁盘的。
  参数：
  - dataset_path：一个字符串，指定数据集的本地路径或远程 URI 。
  - fs：一个 S3FileSystem 或 fsspec.spec.AbstractFileSystem，指定远程文件系统用于下载文件。
  - keep_in_memory：一个布尔值，指定是否拷贝数据集到内存。
  返回一个 Dataset 或 DatasetDict ，这取决于 dataset_path 是否包含单个 split 还是多个 split 。
- datasets.load_dataset_builder()：从 Hugging Face Hub 或本地数据集中加载一个 dataset builder。
  一个 dataset builder 可以用于探查数据集的通用信息而无需下载该数据集。
```
xxxxxxxxxx
load_dataset_builder(
    path: str,
    name: Optional[str] = None,
    data_dir: Optional[str] = None,
    data_files: Optional[Union[str, Sequence[str], Mapping[str, Union[str, Sequence[str]]]]] = None,
    cache_dir: Optional[str] = None,
    features: Optional[Features] = None,
    download_config: Optional[DownloadConfig] = None,
    download_mode: Optional[DownloadMode] = None,
    revision: Optional[Union[str, Version]] = None,
    use_auth_token: Optional[Union[bool, str]] = None,
    **config_kwargs,
) -> DatasetBuilder
```
  参数：参考 load_dataset() 。
  返回一个 DatasetBuilder 。
- datasets.get_dataset_config_names()：对于给定的数据集，返回可用的配置名字的列表。
```
xxxxxxxxxx
get_dataset_config_names(
    path: str,
    revision: Optional[Union[str, Version]] = None,
    download_config: Optional[DownloadConfig] = None,
    download_mode: Optional[DownloadMode] = None,
    dynamic_modules_path: Optional[str] = None,
    data_files: Optional[Union[Dict, List, str]] = None,
    **download_kwargs,
)
```
  参数：参考 load_dataset() 。
- datasets.get_dataset_infos()：获取数据集的源信息，返回一个字典，键位配置名字、值为 DatasetInfoDict 。
```
xxxxxxxxxx
get_dataset_infos(
    path: str,
    data_files: Optional[Union[Dict, List, str]] = None,
    download_config: Optional[DownloadConfig] = None,
    download_mode: Optional[DownloadMode] = None,
    revision: Optional[Union[str, Version]] = None,
    use_auth_token: Optional[Union[bool, str]] = None,
    **config_kwargs,
)
```
  参数：参考 load_dataset() 。
- datasets.get_dataset_split_names()：对于给定的数据和配置，返回可用 split 的列表。
```
xxxxxxxxxx
get_dataset_split_names(
    path: str,
    config_name: Optional[str] = None,
    data_files: Optional[Union[str, Sequence[str], Mapping[str, Union[str, Sequence[str]]]]] = None,
    download_config: Optional[DownloadConfig] = None,
    download_mode: Optional[DownloadMode] = None,
    revision: Optional[Union[str, Version]] = None,
    use_auth_token: Optional[Union[bool, str]] = None,
    **config_kwargs,
)
```
  参数：
  - config_name：一个字符串，指定数据集配置的名字。
  - 其它参数参考 load_dataset() 。
- datasets.inspect_dataset()：将 dataset script 拷贝到本地磁盘从而允许探查和修改它。
```
xxxxxxxxxx
inspect_dataset(path: str, local_path: str, download_config: Optional[DownloadConfig] = None, **download_kwargs)
```
  参数：
  - local_path：一个字符串，指定 dataset script 要拷贝到哪里。
  - 其它参数参考 load_dataset() 。

你可以传入一些参数到 load_dataset 从而配置数据加载。例如，对于 csv 文件的加载，你可以指定 sep 参数：


xxxxxxxxxx
load_dataset("csv", data_dir="path/to/data/dir", sep="\t")

针对不同文件格式的配置类，可以在 load_dataset 中指定相应的参数：

class datasets.packaged_modules.text.TextConfig：针对文本文件的 BuilderConfig 。


xxxxxxxxxx
class datasets.packaged_modules.text.TextConfig(
  name: str = 'default',
  version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
  data_dir: typing.Optional[str] = None,
  data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
  description: typing.Optional[str] = None,
  features: typing.Optional[datasets.features.features.Features] = None,
  encoding: str = 'utf-8',
  errors: typing.Optional[str] = None,
  chunksize: int = 10485760,
  keep_linebreaks: bool = False,
  sample_by: str = 'line' )

class datasets.packaged_modules.csv.CsvConfig：针对csv 文件的 BuilderConfig 。


xxxxxxxxxx
class datasets.packaged_modules.csv.CsvConfig(
  name: str = 'default',
  version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
  data_dir: typing.Optional[str] = None,
  data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
  description: typing.Optional[str] = None,
  sep: str = ',',
  delimiter: typing.Optional[str] = None,
  header: typing.Union[int, typing.List[int], str, NoneType] = 'infer',
  names: typing.Optional[typing.List[str]] = None,
  column_names: typing.Optional[typing.List[str]] = None,
  index_col: typing.Union[int, str, typing.List[int], typing.List[str], NoneType] = None,
  usecols: typing.Union[typing.List[int], typing.List[str], NoneType] = None,
  prefix: typing.Optional[str] = None,
  mangle_dupe_cols: bool = True,
  engine: typing.Optional[str] = None,
  converters: typing.Dict[typing.Union[int, str], typing.Callable[[typing.Any], typing.Any]] = None,
  true_values: typing.Optional[list] = None,
  false_values: typing.Optional[list] = None,
  skipinitialspace: bool = False,
  skiprows: typing.Union[int, typing.List[int], NoneType] = None,
  nrows: typing.Optional[int] = None,
  na_values: typing.Union[str, typing.List[str], NoneType] = None,
  keep_default_na: bool = True,
  na_filter: bool = True,
  verbose: bool = False,
  mskip_blank_lines: bool = True,
  thousands: typing.Optional[str] = None,
  decimal: str = '.',
  lineterminator: typing.Optional[str] = None,
  quotechar: str = '"',
  quoting: int = 0,
  escapechar: typing.Optional[str] = None,
  comment: typing.Optional[str] = None,
  encoding: typing.Optional[str] = None,
  dialect: typing.Optional[str] = None,
  error_bad_lines: bool = True,
  warn_bad_lines: bool = True,
  skipfooter: int = 0,
  doublequote: bool = True,
  memory_map: bool = False,
  float_precision: typing.Optional[str] = None,
  chunksize: int = 10000,
  features: typing.Optional[datasets.features.features.Features] = None,
  encoding_errors: typing.Optional[str] = 'strict',
  on_bad_lines: typing.Literal['error', 'warn', 'skip'] = 'error'
)

class datasets.packaged_modules.json.JsonConfig：针对json 文件的 BuilderConfig 。


xxxxxxxxxx
class datasets.packaged_modules.json.JsonConfig(
  name: str = 'default',
  version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
  data_dir: typing.Optional[str] = None,
  data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
  description: typing.Optional[str] = None,
  features: typing.Optional[datasets.features.features.Features] = None,
  field: typing.Optional[str] = None,
  use_threads: bool = True,
  block_size: typing.Optional[int] = None,
  chunksize: int = 10485760,
  newlines_in_values: typing.Optional[bool] = None 
)

class datasets.packaged_modules.parquet.ParquetConfig：针对parquet 文件的 BuilderConfig 。


xxxxxxxxxx
class datasets.packaged_modules.parquet.ParquetConfig(
  name: str = 'default',
  version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
  data_dir: typing.Optional[str] = None,
  data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
  description: typing.Optional[str] = None,
  batch_size: int = 10000,
  columns: typing.Optional[typing.List[str]] = None,
  features: typing.Optional[datasets.features.features.Features] = None
)

class datasets.packaged_modules.sql.SqlConfig：针对 sql 的 BuilderConfig 。


xxxxxxxxxx
class datasets.packaged_modules.sql.SqlConfig(
  name: str = 'default',
  version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
  data_dir: typing.Optional[str] = None,
  data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
  description: typing.Optional[str] = None,
  sql: typing.Union[str, ForwardRef('sqlalchemy.sql.Selectable')] = None,
  con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), 
                    ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')] = None,
  index_col: typing.Union[str, typing.List[str], NoneType] = None,
  coerce_float: bool = True,
  params: typing.Union[typing.List, typing.Tuple, typing.Dict, NoneType] = None,
  parse_dates: typing.Union[typing.List, typing.Dict, NoneType] = None,
  columns: typing.Optional[typing.List[str]] = None,
  chunksize: typing.Optional[int] = 10000,
  features: typing.Optional[datasets.features.features.Features] = None
)

class datasets.packaged_modules.imagefolder.ImageFolderConfig：针对 ImageFolder 的 BuilderConfig 。


xxxxxxxxxx
class datasets.packaged_modules.imagefolder.ImageFolderConfig(
  name: str = 'default',
  version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
  data_dir: typing.Optional[str] = None,
  data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
  description: typing.Optional[str] = None,
  features: typing.Optional[datasets.features.features.Features] = None,
  drop_labels: bool = None,
  drop_metadata: bool = None 
)

class datasets.packaged_modules.audiofolder.AudioFolderConfig：针对 AudioFolder 的 BuilderConfig 。


xxxxxxxxxx
class datasets.packaged_modules.audiofolder.AudioFolderConfig(
  name: str = 'default',
  version: typing.Union[str, datasets.utils.version.Version, NoneType] = 0.0.0,
  data_dir: typing.Optional[str] = None,
  data_files: typing.Optional[datasets.data_files.DataFilesDict] = None,
  description: typing.Optional[str] = None,
  features: typing.Optional[datasets.features.features.Features] = None,
  drop_labels: bool = None,
  drop_metadata: bool = None
)

修改 Datasets 的日志等级：


xxxxxxxxxx
import datasets
datasets.logging.set_verbosity_info()
# 或者 datasets.utils.logging.set_verbosity
# 可用等级: 
#     datasets.logging.CRITICAL, datasets.logging.FATAL
#     datasets.logging.ERROR
#     datasets.logging.WARNING, datasets.logging.WARN
#     datasets.logging.INFO
#     datasets.logging.DEBUG

class datasets.table.Table(table: Table)：对 pyarrow Table 的一个封装，是 InMemoryTable, MemoryMappedTable, ConcatenationTable 的基类。
Table 类实现了 pyarrow Table 的所有基础属性和方法，除了如下的 Table transform：
```
xxxxxxxxxx
slice, filter, flatten, combine_chunks, cast, add_column, append_column, remove_column, set_column, rename_columns, drop
```
datasets.table.list_table_cache_files( table: Table) -> List[str]：返回指定的 table 所加载的缓存文件的路径。
参数：table：一个 Table 对象，表示指定的 Table 。