Datasets documentation

Загрузка

Datasets

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.2.0).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Загрузка

Ваши данные могут храниться в разных местах: на диске локальной машины, в репозитории Github, а также в структурах данных в памяти, таких как словари Python и DataFrames Pandas. Независимо от того, где хранится набор данных, 🤗 Datasets поможет вам его загрузить.

В этом руководстве показано, как загрузить набор данных из:

Hugging Face Hub
Локальные файлы
Данные в памяти
Офлайн
Конкретный срез разбиения

Для получения подробной информации о загрузке других модальностей данных обратитесь к руководству по загрузке аудиоданных, руководству по загрузке изображений, руководству по загрузке видео, руководству по загрузке мешей, руководству по загрузке текстовых данных или руководству по загрузке задач оценки агентов.

Hugging Face Hub

Вы также можете загрузить датасет из любого репозитория датасетов на Hub! Начните с создания репозитория датасета и загрузите файлы с данными. Теперь вы можете использовать функцию load_dataset() для загрузки датасета.

Например, попробуйте загрузить файлы из этого демо-репозитория, указав пространство имён репозитория и имя набора данных. Этот репозиторий содержит файлы 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, объём которого составляет около 13 ТБ.

Вы также можете загрузить конкретный подмножество файлов с помощью параметра 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 также может сопоставить файл данных с конкретным сплитом:

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

Чтобы загрузить удалённые JSON-файлы по HTTP, передайте 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 распознаёт эти другие форматы и при необходимости использует стандартные методы загрузки JSON в Python для их обработки.

Parquet

Файлы Parquet хранятся в столбчатом формате, в отличие от файлов на основе строк, таких как CSV. Большие наборы данных могут храниться в файле Parquet, так как этот формат обеспечивает более высокую эффективность и скорость выполнения запросов.

Для загрузки файла Parquet:

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

Чтобы загрузить удалённые файлы Parquet по HTTP, передайте вместо них 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

Файлы Arrow хранятся в формате колонок в оперативной памяти, в отличие от строковых форматов, таких как CSV, и сжатых форматов, таких как Parquet.

Для загрузки файла Arrow:

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

Чтобы загрузить удалённые файлы Arrow по HTTP, передайте 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 — это открытый мультимодальный формат таблиц lakehouse для ИИ. Таблицы 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")

Фильтры принимают ту же дизъюнктивную нормальную форму, что и загрузчик Parquet: список предикатов вида (column, operator, value) представляет собой конъюнкцию, а список таких списков — дизъюнкцию. Значения null подчиняются семантике SQL — null не удовлетворяет ни одному сравнению, поэтому строка, в которой отфильтрованный столбец содержит null, никогда не возвращается, в том числе для 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 часто используются для хранения больших объёмов числовых данных в научном вычислении и машинном обучении. Загрузка файлов HDF5 с помощью 🤗 Datasets аналогична загрузке файлов 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 timestamp:

>>> 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 — это коллекции задач, используемые для оценки ИИ-агентов. Они состоят из каталогов, а не из файлов данных: каждая задача представляет собой каталог с файлом конфигурации 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

Читайте содержимое базы данных с помощью from_sql(), указав URI для подключения к вашей базе данных. Можно читать как имена таблиц, так и запросы:

>>> 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 и подходит для больших наборов данных с изображениями. Из-за своего размера WebDatasets, как правило, загружаются в режиме потоковой обработки (с использованием 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)

Чтобы загрузить удалённые WebDatasets по HTTP, передайте 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 (файл кристаллографической информации о макромолекулах) — современный стандартный формат для представления трёхмерных структур макромолекул, используемый Банком данных белков (PDB) с 2014 года.

Каждая строка представляет собой один файл структуры и следует той же структуре каталогов, что и 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)

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

Поддерживаются расширения .cif и .mmcif.

GenBank

GenBank — это текстовый формат NCBI для нуклеотидных и белковых последовательностей вместе с их аннотациями. Файлы используют расширение .gb, .gbk или .genbank (опционально со сжатием), а раздел FEATURES каждой записи декодируется в структурированные объекты.

Помимо лёгких разобранных столбцов, каждая строка содержит столбец record типа BioSequence(format="genbank"), который при установленном biopython декодируется в Bio.SeqRecord.SeqRecord. Чтобы получить исходные байты записи в виде {"bytes": ..., "path": None}, приведите этот столбец к типу BioSequence(format="genbank", decode=False), либо исключите его с помощью 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")

Загрузчик возвращает пять столбцов:

Столбец	Тип	Описание
`id`	string	Идентификатор последовательности (первое слово после `@`)
`description`	string	Полная строка описания (всё после id)
`sequence`	large_string	Нуклеотидная последовательность
`quality`	large_string	Качественные оценки в кодировке ASCII
`record`	BioSequence	При `format="fastq"` для каждой записи сохраняются исходные байты, которые при обращении декодируются в объект `SeqRecord` Biopython.

Чтение разобранных столбцов не требует Biopython; исключите record с помощью columns или используйте 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 — это текстовый формат для представления нуклеотидных последовательностей (ДНК/РНК) или пептидных последовательностей (белков), широко используемый в биоинформатике.

Для загрузки файла FASTA:

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

Это возвращает набор данных со следующими столбцами:

id: Идентификатор последовательности (первое слово после >)
description: Полная строка описания (всё после id)
sequence: биологическая последовательность (ДНК/РНК/белок)
record: объект BioSequence с format="fasta", хранящий исходные байты каждой записи и декодирующий их в SeqRecord Biopython при обращении.

Вы также можете загрузить только определённые столбцы:

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

Поддерживаются файлы FASTA с различными расширениями: .fa, .fasta, .fna (нуклеиновые кислоты), .ffn (нуклеотиды генных регионов), .faa (аминокислоты) и .frn (некодирующие РНК). Сжатые файлы (gzip, bzip2, xz) определяются и распаковываются автоматически.

Удалённые файлы

Если у вас есть удалённые файлы, вероятно, сохранённые в формате csv, json, txt, parquet или любом другом поддерживаемом формате, функция load_dataset() может загрузить их, если вы укажете их удалённые пути:

https:// URL-адреса для публичных файлов в интернете, например data_files=["https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json"]
URL-адреса hf:// для файлов в любом репозитории датасета или хранилище на Hugging Face, например 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. В этом случае каждому процессу выделяется подмножество шардов для подготовки:

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 также позволяет создавать Dataset непосредственно из структур данных в памяти, таких как словари Python и DataFrames Pandas.

Словарь Python

Загружайте словари Python с помощью from_dict():

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

Список словарей Python

Загрузите список словарей Python с помощью from_list():

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

Генератор Python

Создайте набор данных из генератора Python с помощью from_generator():

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

Загрузка Pandas DataFrames с помощью from_pandas():

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

Для получения подробной информации ознакомьтесь с руководством как загрузить табличные наборы данных из Pandas DataFrames.

Офлайн

Даже при отсутствии подключения к интернету загрузить датасет всё равно возможно. Если вы ранее скачивали датасет из репозитория Hub, он должен быть закэширован. Это означает, что вы можете перезагрузить датасет из кэша и использовать его в автономном режиме.

Если вы знаете, что у вас не будет доступа в интернет, вы можете запустить 🤗 Datasets в полностью автономном режиме. Это экономит время, так как вместо ожидания тайм-аута загрузки Dataset builder, 🤗 Datasets будет искать данные непосредственно в кэше. Чтобы включить полностью автономный режим, установите переменную окружения HF_HUB_OFFLINE в значение 1.

Разделение на срезы

Вы также можете загрузить только определённые срезы сплита. Существует два способа нарезки сплита: с помощью строк или API ReadInstruction. Строки более компактны и читаемы в простых случаях, тогда как 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]")

Или выберите процент разбиения с помощью:


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

Далее укажите параметр features в load_dataset(), передав в него только что созданные вами признаки:

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

←Обзор Процесс→