# Основные классы

## DatasetInfo[[datasets.DatasetInfo]]

#### datasets.DatasetInfo[[datasets.DatasetInfo]]

```python
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, builder_name: typing.Optional[str] = None, dataset_name: typing.Optional[str] = None, config_name: typing.Optional[str] = None, version: typing.Union[str, datasets.utils.version.Version, NoneType] = None, splits: typing.Optional[datasets.splits.SplitDict] = 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, column_metadata: typing.Optional[dict[str, dict[str, str]]] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/info.py#L92)

**Параметры:**

description (`str`) : Описание набора данных.

citation (`str`) : Цитирование набора данных в формате BibTeX.

homepage (`str`) : URL официальной главной страницы набора данных.

license (`str`) : Лицензия набора данных. Может содержать название лицензии или абзац с условиями лицензии.

features ([Features](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *optional*) : Функции, используемые для указания типов столбцов набора данных.

post_processed (`PostProcessedInfo`, *необязательный*) : Устарело. Информация о ресурсах возможной постобработки набора данных. Например, может содержать информацию об индексе.

supervised_keys (`SupervisedKeysData`, *необязательный*) : Указывает входную характеристику и метку для обучения с учителем, если это применимо к набору данных (устаревшее поле из TFDS).

builder_name (`str`, *необязательный*) : Имя подкласса `GeneratorBasedBuilder`, используемого для создания набора данных. Это также версия имени класса сборщика набора данных в формате snake_case.

config_name (`str`, *необязательный*) : Имя конфигурации, полученной из [BuilderConfig](/docs/datasets/main/ru/package_reference/builder_classes#datasets.BuilderConfig).

version (`str` или [Version](/docs/datasets/main/ru/package_reference/builder_classes#datasets.Version), *необязательный*) : Версия набора данных.

splits (`dict`, *необязательный*) : Соответствие между именем сплита и метаданными.

download_checksums (`dict`, *необязательный*) : Соответствие между URL для загрузки контрольных сумм набора данных и соответствующими метаданными.

download_size (`int`, *optional*) : Размер файлов для скачивания с целью генерации набора данных, в байтах.

post_processing_size (`int`, *optional*) : Устарело. Размер набора данных в байтах после постобработки, если она выполнялась.

dataset_size (`int`, *optional*) : Совокупный размер в байтах таблиц Arrow для всех разбиений.

size_in_bytes (`int`, *optional*) : Совокупный размер в байтах всех файлов, связанных с набором данных (скачанные файлы + файлы Arrow).

column_metadata (`dict[str, dict[str, str]]`, *необязательный*) : метаданные столбцов в виде отображения от имени столбца к строковым ключам и значениям, как метаданные полей Arrow. Записываются в метаданные полей Arrow в файлах Parquet.

- ****config_kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в [BuilderConfig](/docs/datasets/main/ru/package_reference/builder_classes#datasets.BuilderConfig) и используемые в [DatasetBuilder](/docs/datasets/main/ru/package_reference/builder_classes#datasets.DatasetBuilder).

Информация о наборе данных.

`DatasetInfo` описывает наборы данных, включая их имя, версию и признаки. Полный список аргументов конструктора и свойств см. в документации.

Не все поля известны на этапе создания и могут быть обновлены позже.

#### from_directory[[datasets.DatasetInfo.from_directory]]

```python
from_directory(dataset_info_dir: str, storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/info.py#L263)

**Параметры:**

dataset_info_dir (`str`) : каталог, содержащий файл метаданных. Это должен быть корневой каталог конкретной версии набора данных.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

Создайте [DatasetInfo](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetInfo) из JSON-файла в `dataset_info_dir`.

Эта функция обновляет все динамически сгенерированные поля (num_examples, hash, time of creation,...) объекта [DatasetInfo](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetInfo).

Это перезапишет все предыдущие метаданные.

Пример:

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

#### write_to_directory[[datasets.DatasetInfo.write_to_directory]]

```python
write_to_directory(dataset_info_dir, pretty_print = False, storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/info.py#L191)

**Параметры:**

dataset_info_dir (`str`) : Каталог назначения.

pretty_print (`bool`, по умолчанию `False`) : Если `True`, JSON будет отформатирован с отступом в 4 пробела.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

Запишите `DatasetInfo` и лицензию (если она есть) в виде файлов JSON в `dataset_info_dir`.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.info.write_to_directory("/path/to/directory/")
```

## Набор данных[[datasets.Dataset]]

Базовый класс [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) реализует Dataset, основанный на таблице Apache Arrow.

#### datasets.Dataset[[datasets.Dataset]]

```python
datasets.Dataset(arrow_table: Table, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_table: typing.Optional[datasets.table.Table] = None, fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L733)

Набор данных, основанный на таблице Arrow.

#### add_column[[datasets.Dataset.add_column]]

```python
add_column(name: str, column: typing.Union[list, numpy.ndarray], new_fingerprint: typing.Optional[str] = None, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure, NoneType] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6382)

**Параметры:**

name (`str`) : Имя столбца.

column (`list` или `np.array`) : данные столбца, которые нужно добавить.

feature (`FeatureType` или `None`, по умолчанию `None`) : Тип данных столбца.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Добавить столбец в Dataset.

Пример:

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

#### add_item[[datasets.Dataset.add_item]]

```python
add_item(item: dict, new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6644)

**Параметры:**

item (`dict`) : данные элемента, которые нужно добавить.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Добавить элемент в Dataset.

Пример:

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

#### from_file[[datasets.Dataset.from_file]]

```python
from_file(filename: str, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_filename: typing.Optional[str] = None, in_memory: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L820)

**Параметры:**

filename (`str`) : Имя файла набора данных.

info (`DatasetInfo`, *необязательный*) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, *необязательный*) : Имя сплита набора данных.

indices_filename (`str`, *необязательный*) : Имена файлов индексов.

in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создайте экземпляр Dataset, основанный на таблице Arrow с именем файла filename.

#### from_buffer[[datasets.Dataset.from_buffer]]

```python
from_buffer(buffer: Buffer, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, indices_buffer: typing.Optional[pyarrow.lib.Buffer] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L860)

**Параметры:**

buffer (`pyarrow.Buffer`) : буфер Arrow.

info (`DatasetInfo`, *необязательный*) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, *необязательный*) : Имя сплита набора данных.

indices_buffer (`pyarrow.Buffer`, *optional*) : Индексы буфера Arrow.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создайте экземпляр Dataset, использующего буфер Arrow.

#### from_pandas[[datasets.Dataset.from_pandas]]

```python
from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L892)

**Параметры:**

df (`pandas.DataFrame`) : DataFrame, содержащий набор данных.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

info (`DatasetInfo`, *необязательный*) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, *необязательный*) : Имя сплита набора данных.

preserve_index (`bool`, *необязательный*) : Указывает, следует ли сохранять индекс как дополнительный столбец в результирующем Dataset. Значение по умолчанию `None` сохраняет индекс как столбец, за исключением `RangeIndex`, который хранится только в метаданных. Используйте `preserve_index=True`, чтобы принудительно сохранить его как столбец.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Преобразуйте `pandas.DataFrame` в `pyarrow.Table`, чтобы создать [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset).

Типы столбцов в результирующей таблице Arrow выводятся из dtypes `pandas.Series` в DataFrame. Для Series, не являющихся объектами, NumPy dtype преобразуется в соответствующий ему тип Arrow. В случае `object` необходимо определить тип данных, анализируя Python-объекты в этой Series.

Обратите внимание, что Series с типом данных `object` не содержат достаточной информации для однозначного определения осмысленного типа Arrow. Если тип не удаётся вывести, например, если длина DataFrame равна 0 или Series содержит только объекты `None/nan`, тип устанавливается в `null`. Этого поведения можно избежать, явно создав features и передав их в эту функцию.

Important: a dataset created with from_pandas() lives in memory and therefore doesn't have an associated cache directory. This may change in the future, but in the meantime if you want to reduce memory usage you should write it back on disk and reload using e.g. save_to_disk / load_from_disk.

Пример:

```py
>>> ds = Dataset.from_pandas(df)
```

#### from_dict[[datasets.Dataset.from_dict]]

```python
from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1010)

**Параметры:**

mapping (`Mapping`) : отображение строк в массивы или списки Python.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

info (`DatasetInfo`, *необязательный*) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, *необязательный*) : Имя сплита набора данных.

on_mixed_types (`Literal["use_json"]`, *необязательный*, по умолчанию `None`) : Если указано "use_json", для полей со смешанными типами используется тип Json(), то есть для неструктурированных полей, содержащих данные без заранее определённой схемы. В этом случае полю со смешанным типом присваивается Json().  Это позволяет, например, загружать списки, содержащие смесь строк/целых чисел/чисел с плавающей точкой, или словари с произвольными типами значений.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Преобразуйте `dict` в `pyarrow.Table`, чтобы создать [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset).

Important: a dataset created with from_dict() lives in memory and therefore doesn't have an associated cache directory. This may change in the future, but in the meantime if you want to reduce memory usage you should write it back on disk and reload using e.g. save_to_disk / load_from_disk.

Примеры:

Создайте датасет из словаря, содержащего один список на каждый столбец:

```py
>>> ds = Dataset.from_dict({"text": ["hello there !", "general kenobi !"]})
```

Передайте features, чтобы задать типы столбцов, например, для набора данных изображений:

```py
>>> features = Features({"image": Image()})
>>> ds = Dataset.from_dict({"image": ["path/to/image.png"]}, features=features)
```

Датасеты основаны на Arrow, который является колоночным форматом, поэтому ожидается, что каждый пример имеет одинаковый тип и подтипы, а словари — одинаковые ключи и типы значений. При загрузке датасета возникает ошибка, если типы полей не совпадают, а отсутствующие поля в словарях заполняются значением None, чтобы все словари имели одинаковые ключи и типы значений.

Чтобы избежать этого и разрешить смешанные типы без ошибок, вы можете использовать `on_mixed_types="use_json"` или указать `features=` с типом [Json](/docs/datasets/main/ru/package_reference/loading_methods#datasets.Json):

```py
>>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]})
Traceback (most recent call last):
  ...
  File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status
pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64

>>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, on_mixed_types="use_json")
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]

>>> features = Features({"a": Json()})
>>> ds = Dataset.from_dict({"a": [0, "foo", {"subfield": "bar"}]}, features=features)
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]
```

Это также полезно для списков словарей с произвольными ключами и значениями, чтобы избежать заполнения отсутствующих полей значением None:

```py
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]})
>>> ds.features
{'a': List({'b': Value('int64'), 'c': Value('int64')})}
>>> list(ds["a"])
[[{'b': 0, 'c': None}, {'b': None, 'c': 0}]]  # missing fields are filled with None

>>> features = Features({"a": List(Json())})
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features)
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK

>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json")
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK
```

Ещё один пример с данными для вызова инструментов:

```py
>>> messages = [
...     {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."},
...     {"role": "assistant", "tool_calls": [
...         {"type": "function", "function": {
...             "name": "control_light",
...             "arguments": {"room": "living room", "state": "on"}
...         }},
...         {"type": "function", "function": {
...             "name": "play_music",
...             "arguments": {"playlist": "electronic"}  # mixed-type here since keys ["playlist"] and ["room", "state"] are different
...         }}]
...     },
...     {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."},
...     {"role": "tool", "name": "play_music", "content": "The music is now playing."},
...     {"role": "assistant", "content": "Done!"}
... ]
>>> ds = Dataset.from_dict({"messages": [messages]}, on_mixed_types="use_json")
>>> ds.features
{'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})}
>>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"]
{"room": "living room", "state": "on"}
```

#### from_list[[datasets.Dataset.from_list]]

```python
from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1176)

**Параметры:**

mapping (`List[dict]`) : список отображений строк в значения строк.

features (`Features`, необязательно) : Функции набора данных.

info (`DatasetInfo`, optional) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, optional) : Имя сплита набора данных.

on_mixed_types (`Literal["use_json"]`, *необязательный*, по умолчанию `None`) : Если указано "use_json", для полей со смешанными типами используется тип Json(), то есть для неструктурированных полей, содержащих данные без заранее определённой схемы. В этом случае полю со смешанным типом присваивается Json().  Это позволяет, например, загружать списки, содержащие смесь строк/целых чисел/чисел с плавающей точкой, или словари с произвольными типами значений.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Преобразуйте список словарей в `pyarrow.Table`, чтобы создать [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)`.

Обратите внимание, что ключи первого элемента будут использоваться для определения столбцов набора данных, независимо от того, что передано в features.

Important: a dataset created with from_list() lives in memory and therefore doesn't have an associated cache directory. This may change in the future, but in the meantime if you want to reduce memory usage you should write it back on disk and reload using e.g. save_to_disk / load_from_disk.

Примеры:

Создайте датасет из списка, содержащего примеры:

```py
>>> ds = Dataset.from_list([{"text": "hello there !"}, {"text": "general kenobi !"}]})
```

Передайте features, чтобы задать типы столбцов, например, для набора данных изображений:

```py
>>> features = Features({"image": Image()})
>>> ds = Dataset.from_list([{"image": "path/to/image.png"}], features=features)
```

Датасеты основаны на Arrow, который является колоночным форматом, поэтому ожидается, что каждый пример имеет одинаковый тип и подтипы, а словари — одинаковые ключи и типы значений. При загрузке датасета возникает ошибка, если типы полей не совпадают, а отсутствующие поля в словарях заполняются значением None, чтобы все словари имели одинаковые ключи и типы значений.

Чтобы избежать этого и разрешить смешанные типы без ошибок, вы можете использовать `on_mixed_types="use_json"` или указать `features=` с типом [Json](/docs/datasets/main/ru/package_reference/loading_methods#datasets.Json):

```py
>>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}])
Traceback (most recent call last):
  ...
  File "pyarrow/error.pxi", line 92, in pyarrow.lib.check_status
pyarrow.lib.ArrowInvalid: Could not convert 'foo' with type str: tried to convert to int64

>>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], on_mixed_types="use_json")
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]

>>> features = Features({"a": Json()})
>>> ds = Dataset.from_list([{"a": 0}, {"a": "foo"}, {"a": {"subfield": "bar"}}], features=features)
>>> ds.features
{'a': Json()}
>>> list(ds["a"])
[0, "foo", {"subfield": "bar"}]
```

Это также полезно для списков словарей с произвольными ключами и значениями, чтобы избежать заполнения отсутствующих полей значением None:

```py
>>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}])
>>> ds.features
{'a': List({'b': Value('int64'), 'c': Value('int64')})}
>>> list(ds["a"])
[[{'b': 0, 'c': None}, {'b': None, 'c': 0}]]  # missing fields are filled with None

>>> features = Features({"a": List(Json())})
>>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], features=features)
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK

>>> ds = Dataset.from_list([{"a": [{"b": 0}, {"c": 0}]}], on_mixed_types="use_json")
>>> ds.features
{'a': List(Json())}
>>> list(ds["a"])
[[{'b': 0}, {'c': 0}]]  # OK
```

Ещё один пример с данными для вызова инструментов:

```py
>>> messages = [
...     {"role": "user", "content": "Turn on the living room lights and play my electronic music playlist."},
...     {"role": "assistant", "tool_calls": [
...         {"type": "function", "function": {
...             "name": "control_light",
...             "arguments": {"room": "living room", "state": "on"}
...         }},
...         {"type": "function", "function": {
...             "name": "play_music",
...             "arguments": {"playlist": "electronic"}  # mixed-type here since keys ["playlist"] and ["room", "state"] are different
...         }}]
...     },
...     {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."},
...     {"role": "tool", "name": "play_music", "content": "The music is now playing."},
...     {"role": "assistant", "content": "Done!"}
... ]
>>> ds = Dataset.from_list([{"messages": messages}], on_mixed_types="use_json")
>>> ds.features
{'messages': List({'role': Value('string'), 'content': Value('string'), 'tool_calls': List(Json()), 'name': Value('string')})}
>>> ds[0]["messages"][1]["tool_calls"][0]["function"]["arguments"]
{"room": "living room", "state": "on"}
```

#### from_generator[[datasets.Dataset.from_generator]]

```python
from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, gen_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, split: NamedSplit = NamedSplit('train'), fingerprint: typing.Optional[str] = None, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1365)

**Параметры:**

generator ( --`Callable`): функция-генератор, которая `yields` примеры.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

gen_kwargs(`dict`, *необязательный*) : Аргументы с ключами, передаваемые вызываемому объекту `generator`. Вы можете определить датасет с шардами, передав список шардов в `gen_kwargs` и установив `num_proc` больше 1.

num_proc (`int`, *необязательный*, по умолчанию `None`) : Количество процессов при загрузке и локальной генерации набора данных. Это полезно, если набор данных состоит из нескольких файлов. Многопоточность по умолчанию отключена. Если `num_proc` больше одного, то все значения списков в `gen_kwargs` должны иметь одинаковую длину. Эти значения будут распределены между вызовами генератора. Количество фрагментов будет равно минимуму из длины самого короткого списка в `gen_kwargs` и значения `num_proc`.

split ([NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), по умолчанию `Split.TRAIN`) : Имя сплита, которое будет присвоено набору данных.

fingerprint (`str`, *необязательный*) : Отпечаток, который будет использоваться для генерации идентификатора набора данных. По умолчанию `fingerprint` генерируется путём хеширования функции-генератора и всех аргументов, что может быть медленным, если используются крупные объекты, такие как модели ИИ.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в :`GeneratorConfig`.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создание Dataset из генератора.

Загрузите данные из генератора, закэшируйте их на диске в формате Arrow и верните Dataset из данных Arrow на диске, отображённых в память.

Пример:

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

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

#### data[[datasets.Dataset.data]]

```python
data()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2138)

Таблица Apache Arrow, лежащая в основе набора данных.

Пример:

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

#### cache_files[[datasets.Dataset.cache_files]]

```python
cache_files()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2158)

Файлы кэша, содержащие таблицу Apache Arrow, лежащую в основе набора данных.

Пример:

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

#### num_columns[[datasets.Dataset.num_columns]]

```python
num_columns()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2176)

Количество столбцов в наборе данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.num_columns
2
```

#### num_rows[[datasets.Dataset.num_rows]]

```python
num_rows()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2191)

Количество строк в наборе данных (то же, что и [Dataset.__len__()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.__len__)).

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.num_rows
1066
```

#### column_names[[datasets.Dataset.column_names]]

```python
column_names()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2208)

Имена столбцов в наборе данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.column_names
['text', 'label']
```

#### shape[[datasets.Dataset.shape]]

```python
shape()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2223)

Форма набора данных (количество столбцов, количество строк).

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.shape
(1066, 2)
```

#### unique[[datasets.Dataset.unique]]

```python
unique(column: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2240)

**Параметры:**

column (`str`) : Имя столбца (список всех имён столбцов — [column_names](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.column_names)).

**Возвращает:** `list`

Список уникальных элементов в указанном столбце.

Возвращает список уникальных элементов в столбце.

Это реализовано в низкоуровневом бэкенде и, как следствие, работает очень быстро.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.unique('label')
[1, 0]
```

#### flatten[[datasets.Dataset.flatten]]

```python
flatten(new_fingerprint: typing.Optional[str] = None, max_depth = 16)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2346)

**Параметры:**

new_fingerprint (`str`, *необязательный*) : Новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Копия набора данных с выровненными столбцами.

Разверните таблицу. Каждая колонка со структурой (struct) разворачивается в одну колонку на каждое поле структуры. Остальные колонки остаются без изменений.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("rajpurkar/squad", split="train")
>>> ds.features
{'id': Value('string'),
 'title': Value('string'),
 'context': Value('string'),
 'question': Value('string'),
 'answers': {'text': List(Value('string')),
 'answer_start': List(Value('int32'))}}
>>> ds = ds.flatten()
>>> ds
Dataset({
    features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'],
    num_rows: 87599
})
```

#### cast[[datasets.Dataset.cast]]

```python
cast(features: Features, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, num_proc: typing.Optional[int] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2393)

**Параметры:**

features ([Возможности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features)) : Новые возможности для приведения набора данных. Имена полей в возможностях должны совпадать с текущими именами столбцов. Тип данных также должен допускать преобразование из одного типа в другой. Для нетривиальных преобразований, например `str` <-> `ClassLabel`, следует использовать [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.map) для обновления набора данных.

batch_size (`int`, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемой в cast. Если `batch_size <= 0` или `batch_size == None`, то весь набор данных передается в cast как одна партия.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

load_from_cache_file (`bool`, по умолчанию `True`, если кэширование включено): если можно определить файл кэша, содержащий текущий результат вычислений из `function`, использовать его вместо повторного вычисления.

cache_file_name (`str`, *необязательный*, по умолчанию `None`) : Укажите имя пути к файлу кэша. Используется для хранения результатов вычислений вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений при обработке, а более низкое значение потребляет меньше временной памяти во время выполнения [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.map).

num_proc (`int`, *необязательный*, по умолчанию `None`) : Количество процессов для многопроцессности. По умолчанию многопроцессность не используется.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Копия набора данных с преобразованными признаками.

Преобразовать набор данных в новый набор признаков.

Пример:

```py
>>> from datasets import load_dataset, ClassLabel, Value
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds.features.copy()
>>> new_features['label'] = ClassLabel(names=['bad', 'good'])
>>> new_features['text'] = Value('large_string')
>>> ds = ds.cast(new_features)
>>> ds.features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### cast_column[[datasets.Dataset.cast_column]]

```python
cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure], new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2477)

**Параметры:**

column (`str`) : Имя столбца.

feature (`FeatureType`) : целевая функция.

new_fingerprint (`str`, *необязательный*) : Новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Преобразование столбца в признак для декодирования.

Пример:

```py
>>> from datasets import load_dataset, ClassLabel
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good']))
>>> ds.features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('string')}
```

#### remove_columns[[datasets.Dataset.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2520)

**Параметры:**

column_names (`Union[str, List[str]]`) : Имя столбца (столбцов) для удаления.

new_fingerprint (`str`, *необязательный*) : Новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Копия объекта набора данных без удаляемых столбцов.

Удалите одну или несколько колонок в наборе данных, а также связанные с ними признаки.

Также можно удалить столбец с помощью [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.map) и параметра `remove_columns`, но описанный выше метод не копирует данные оставшихся столбцов, поэтому работает быстрее.

Пример:

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

#### rename_column[[datasets.Dataset.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str, new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2579)

**Параметры:**

original_column_name (`str`) : Имя переименовываемой колонки.

new_column_name (`str`) : Новое имя столбца.

new_fingerprint (`str`, *необязательный*) : Новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Копия набора данных с переименованной колонкой.

Переименуйте столбец в наборе данных и переместите признаки, связанные с исходным столбцом, под новое имя столбца.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.rename_column('label', 'label_new')
Dataset({
    features: ['text', 'label_new'],
    num_rows: 1066
})
```

#### rename_columns[[datasets.Dataset.rename_columns]]

```python
rename_columns(column_mapping: dict, new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2648)

**Параметры:**

column_mapping (`Dict[str, str]`) : Соответствие столбцов, которые нужно переименовать, и их новых имён

new_fingerprint (`str`, *необязательный*) : Новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Копия набора данных с переименованными столбцами

Переименуйте несколько столбцов в наборе данных и переместите признаки, связанные с исходными столбцами, под новыми именами столбцов.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.rename_columns({'text': 'text_new', 'label': 'label_new'})
Dataset({
    features: ['text_new', 'label_new'],
    num_rows: 1066
})
```

#### select_columns[[datasets.Dataset.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]], new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2716)

**Параметры:**

column_names (`Union[str, List[str]]`) : Имя столбца (столбцов), который нужно сохранить.

new_fingerprint (`str`, *необязательный*) : Новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Копия объекта набора данных, содержащая только выбранные столбцы.

Выберите одну или несколько колонок в наборе данных и связанные с ними признаки.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.select_columns(['text'])
>>> ds
Dataset({
    features: ['text'],
    num_rows: 1066
})
```

#### with_column_metadata[[datasets.Dataset.with_column_metadata]]

```python
with_column_metadata(column_metadata: dict)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2769)

**Параметры:**

column_metadata (`dict[str, dict[str, str]]`) : Соответствие между именем столбца и его новыми метаданными. Заменяет текущие метаданные этих столбцов; пустой словарь удаляет их. Метаданные остальных столбцов не изменяются.

Возвращает набор данных с указанными метаданными для некоторых столбцов.

The metadata of a column is a dict of strings, like the metadata of Arrow fields. It's kept in `DatasetInfo.column_metadata`, follows the column when it's renamed, and is written in the Arrow field metadata of the Parquet files of [to_parquet()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.to_parquet) and [push_to_hub()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.push_to_hub).

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.with_column_metadata({"text": {"language": "en"}})
>>> ds.info.column_metadata
{'text': {'language': 'en'}}
```

#### class_encode_column[[datasets.Dataset.class_encode_column]]

```python
class_encode_column(column: str, include_nulls: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2271)

**Параметры:**

column (`str`) : имя столбца, который нужно преобразовать (список всех имён столбцов — [column_names](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.column_names))

include_nulls (`bool`, по умолчанию `False`) : Включать ли значения null в классы меток. Если `True`, значения null будут закодированы как метка класса `"None"`.

Преобразует указанную колонку в [ClassLabel](/docs/datasets/main/ru/package_reference/main_classes#datasets.ClassLabel) и обновляет таблицу.

Пример:

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

#### __len__[[datasets.Dataset.__len__]]

```python
__len__()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2818)

Количество строк в наборе данных.

Пример:

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

#### __iter__[[datasets.Dataset.__iter__]]

```python
__iter__()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2835)

Переберите примеры.

Если форматирование установлено с помощью [Dataset.set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format), строки будут возвращаться в выбранном формате.

#### iter[[datasets.Dataset.iter]]

```python
iter(batch_size: int, drop_last_batch: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2864)

**Параметры:**

batch_size (`int`) : размер каждой порции, которую нужно выдавать.

drop_last_batch (`bool`, по умолчанию *False*) : следует ли отбрасывать последний батч, если его размер меньше batch_size

Перебирайте батчи размера *batch_size*.

Если форматирование установлено с помощью [*~datasets.Dataset.set_format*], строки будут возвращены в выбранном формате.

#### formatted_as[[datasets.Dataset.formatted_as]]

```python
formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2908)

**Параметры:**

type (`str`, *необязательный*) : Тип вывода, выбранный из `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` означает, что `__getitem__`` возвращает объекты Python (по умолчанию).

columns (`List[str]`, *необязательный*) : Столбцы для форматирования в выводе. `None` означает, что `__getitem__` возвращает все столбцы (по умолчанию).

output_all_columns (`bool`, по умолчанию `False`) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python).

- ****format_kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в функцию преобразования, например `np.array`, `torch.tensor` или `tensorflow.ragged.constant`.

Используется в операторе `with`. Задаёт формат возврата `__getitem__` (тип и столбцы).

#### set_format[[datasets.Dataset.set_format]]

```python
set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2940)

**Параметры:**

type (`str`, *необязательный*) : Тип вывода, выбранный из `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` означает, что `__getitem__` возвращает объекты Python (по умолчанию).

columns (`List[str]`, *необязательный*) : Столбцы для форматирования в выводе. `None` означает, что `__getitem__` возвращает все столбцы (по умолчанию).

output_all_columns (`bool`, по умолчанию `False`) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python).

- ****format_kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в функцию преобразования, например `np.array`, `torch.tensor` или `tensorflow.ragged.constant`.

Формат возвращаемого значения `__getitem__` (тип и столбцы). Форматирование данных выполняется на лету. Формат `type` (например, "numpy") используется для форматирования батчей при использовании `__getitem__`. Также можно использовать пользовательские трансформации для форматирования с помощью [set_transform()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_transform).

Возможно вызвать [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.map) после вызова `set_format`. Поскольку `map` может добавлять новые столбцы, список отформатированных столбцов

обновляется. В этом случае, если вы примените `map` к набору данных для добавления нового столбца, этот столбец будет отформатирован следующим образом:

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

Пример:

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

#### set_transform[[datasets.Dataset.set_transform]]

```python
set_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3048)

**Параметры:**

transform (`Callable`, *необязательный*) : Пользовательское преобразование форматирования, заменяющее формат, определённый в [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format). Функция форматирования — это вызываемый объект, который принимает батч (в виде `dict`) на вход и возвращает батч. Эта функция применяется непосредственно перед возвратом объектов в `__getitem__`.

columns (`List[str]`, *необязательный*) : Столбцы, которые нужно отформатировать в выводе. Если указано, то входная партия данных для преобразования содержит только эти столбцы.

output_all_columns (`bool`, по умолчанию `False`) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python). Если установлено в True, остальные неформатированные столбцы сохраняются вместе с результатом преобразования.

Используйте этот трансформ для установки формата возврата `__getitem__`. Трансформ применяется на лету к батчам при вызове `__getitem__`. Как и в случае с [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format), его можно сбросить с помощью [reset_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.reset_format).

Пример:

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

#### reset_format[[datasets.Dataset.reset_format]]

```python
reset_format()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3019)

Сбросить формат возврата `__getitem__` до объектов Python и всех столбцов.

Аналогично `self.set_format()`

Пример:

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

#### with_format[[datasets.Dataset.with_format]]

```python
with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3091)

**Параметры:**

type (`str`, *необязательный*) : Тип вывода, выбранный из `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` означает, что `__getitem__` возвращает объекты Python (по умолчанию).

columns (`List[str]`, *необязательный*) : Столбцы для форматирования в выводе. `None` означает, что `__getitem__` возвращает все столбцы (по умолчанию).

output_all_columns (`bool`, по умолчанию `False`) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python).

- ****format_kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в функцию преобразования, например `np.array`, `torch.tensor` или `tensorflow.ragged.constant`.

Формат возвращаемого значения `__getitem__` (тип и столбцы). Форматирование данных выполняется на лету. Формат `type` (например, "numpy") используется для форматирования батчей при использовании `__getitem__`.

Также можно использовать пользовательские преобразования для форматирования с помощью [with_transform()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.with_transform).

В отличие от [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format), `with_format` возвращает новый объект [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset).

Пример:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds.format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': None}
>>> ds = ds.with_format("torch")
>>> ds.format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': 'torch'}
>>> ds[0]
{'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'label': tensor(1),
 'input_ids': tensor([  101, 18027, 16310, 16001,  1103,  9321,   178, 11604,  7235,  6617,
        1742,  2165,  2820,  1206,  6588, 22572, 12937,  1811,  2153,  1105,
        1147, 12890, 19587,  6463,  1105, 15026,  1482,   119,   102,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}
```

#### with_transform[[datasets.Dataset.with_transform]]

```python
with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3162)

**Параметры:**

transform (`Callable`, `optional`) : Пользовательское преобразование форматирования, заменяющее формат, определённый в [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format). Функция форматирования — это вызываемый объект, который принимает батч (в виде `dict`) на вход и возвращает батч. Эта функция применяется непосредственно перед возвратом объектов в `__getitem__`.

columns (`List[str]`, `optional`) : Столбцы, которые нужно отформатировать в выводе. Если указано, то входная партия данных для преобразования содержит только эти столбцы.

output_all_columns (`bool`, по умолчанию `False`) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python). Если установлено в `True`, остальные неформатированные столбцы сохраняются вместе с результатом преобразования.

Используйте этот трансформ для задания формата возврата `__getitem__`. Трансформ применяется на лету к батчам при вызове `__getitem__`.

Как и [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format), это можно сбросить с помощью [reset_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.reset_format).

В отличие от [set_transform()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_transform), `with_transform` возвращает новый объект [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset).

Пример:

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

#### __getitem__[[datasets.Dataset.__getitem__]]

```python
__getitem__(key)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3238)

Может использоваться для индексации столбцов (по строковым именам) или строк (по целочисленному индексу или итерируемой коллекции индексов или булевых значений).

#### cleanup_cache_files[[datasets.Dataset.cleanup_cache_files]]

```python
cleanup_cache_files()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3251)

**Возвращает:** `int`

Количество удалённых файлов.

Удалите все файлы кэша в каталоге кэша датасета, за исключением используемого в данный момент файла кэша, если таковой имеется.

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

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds.cleanup_cache_files()
10
```

#### map[[datasets.Dataset.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = 'use_json')
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L3298)

**Параметры:**

function (`Callable`) : Функция с одним из следующих сигнатур:  - `function(example: Dict[str, Any]) -> Dict[str, Any]`, если `batched=False` и `with_indices=False` и `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]`, если `batched=False` и `with_indices=True` и/или `with_rank=True` (один дополнительный аргумент для каждого) - `function(batch: Dict[str, List]) -> Dict[str, List]`, если `batched=True` и `with_indices=False` и `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]`, если `batched=True` и `with_indices=True` и/или `with_rank=True` (один дополнительный аргумент для каждого)  Для расширенного использования функция также может возвращать `pyarrow.Table`. Если функция асинхронная, `map` выполнит её параллельно. Кроме того, если функция ничего не возвращает (`None`), `map` выполнит её и вернёт датасет без изменений. Если функция не задана, по умолчанию используется тождественная функция: `lambda x: x`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx[, rank]): ...`.

with_rank (`bool`, по умолчанию `False`) : Передать ранг процесса в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example[, idx], rank): ...`.

input_columns (`Optional[Union[str, List[str]]]`, по умолчанию `None`) : Столбцы, которые передаются в `function` как позиционные аргументы. Если `None`, в качестве одного аргумента передаётся `dict` с отображением на все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`.

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched=True`. Если `batch_size <= 0` или `batch_size == None`, весь набор данных передается в `function` как одна партия.

drop_last_batch (`bool`, по умолчанию `False`) : следует ли отбрасывать последний батч, если его размер меньше batch_size, вместо того чтобы обрабатывать его функцией.

remove_columns (`Optional[Union[str, List[str]]]`, по умолчанию `None`) : Удаляет выбранные столбцы во время выполнения маппинга. Столбцы удаляются до обновления примеров с помощью вывода `function`, то есть если `function` добавляет столбцы с именами из `remove_columns`, эти столбцы будут сохранены.

keep_in_memory (`bool`, по умолчанию `False`) : Держать датасет в памяти, а не записывать его в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий текущие вычисления из `function`, использовать его вместо повторного вычисления.

cache_file_name (`str`, *необязательный*, по умолчанию `None`) : Укажите имя пути к файлу кэша. Используется для хранения результатов вычислений вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

features (`Optional[datasets.Features]`, по умолчанию `None`) : Использовать определённые Features для хранения файла кэша вместо автоматически сгенерированных.

disable_nullable (`bool`, по умолчанию `False`) : Запретить значения null в таблице.

fn_kwargs (`Dict`, *необязательный*, по умолчанию `None`) : Именованные аргументы, передаваемые в `function`.

num_proc (`int`, *необязательный*, по умолчанию `None`) : Количество процессов для использования в многопроцессной обработке. - Если `None` или `0`, многопроцессная обработка не используется, и операция выполняется в основном процессе. - Если значение больше `1`, для параллельной обработки данных используется один или несколько рабочих процессов. Примечание: функция, передаваемая в `map()`, должна быть сериализуемой (picklable), чтобы многопроцессная обработка работала корректно (т. е. предпочтительнее использовать функции, определенные на верхнем уровне модуля, а не внутри другой функции или класса). suffix_template (`str`): Если указано `cache_file_name`, этот суффикс будет добавлен в конец базового имени каждого файла. По умолчанию `"_{rank:05d}_of_{num_proc:05d}"`. Например, если `cache_file_name` равно "processed.arrow", то для `rank=1` и `num_proc=4` результирующий файл будет `"processed_00001_of_00004.arrow"` при использовании суффикса по умолчанию.

new_fingerprint (`str`, *необязательный*, по умолчанию `None`) : новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

desc (`str`, *необязательный*, по умолчанию `None`) : Осмысленное описание, отображаемое рядом с прогресс-баром при отображении примеров.

try_original_type (`Optional[bool]`, по умолчанию `True`) : Пытаться сохранять типы исходных столбцов (например, int32 -> int32). Установите False, если вы хотите всегда выводить новые типы.

on_mixed_types (`Literal["use_json"]`, *необязательный*, по умолчанию `None`) : Если указано "use_json", для полей со смешанными типами используется тип Json(), то есть для неструктурированных полей, содержащих данные без заранее определённой схемы. В этом случае полю со смешанным типом присваивается Json().  Это позволяет, например, загружать списки, содержащие смесь строк/целых чисел/чисел с плавающей точкой, или словари с произвольными типами значений.

Примените функцию ко всем примерам в таблице (по отдельности или партиями) и обновите таблицу. Если ваша функция возвращает столбец, который уже существует, он будет перезаписан.

Вы можете указать, должна ли функция обрабатываться батчами или нет, с помощью параметра `batched`:

- Если `False`, функция принимает один пример и должна вернуть один пример. Примером является словарь, например `{"text": "Hello there !"}`.
- If batched is `True` and `batch_size` is 1, then the function takes a batch of 1 example as input and can return a batch with 1 or more examples. A batch is a dictionary, e.g. a batch of 1 example is `{"text": ["Hello there !"]}`.
- Если `True` и `batch_size` равно `n > 1`, функция принимает на вход батч из `n` примеров и может вернуть батч из `n` примеров или произвольного количества примеров. Обратите внимание, что в последнем батче может быть меньше `n` примеров. Батч — это словарь, например, батч из `n` примеров имеет вид `{"text": ["Hello there !"] * n}`.

Если функция асинхронная, то `map` будет выполнять её параллельно, с максимумом в тысячу одновременных вызовов. Рекомендуется использовать `asyncio.Semaphore` в вашей функции, если вы хотите задать максимальное количество операций, которые могут выполняться одновременно.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> def add_prefix(example):
...     example["text"] = "Review: " + example["text"]
...     return example
>>> ds = ds.map(add_prefix)
>>> ds[0:3]["text"]
['Review: compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'Review: the soundtrack alone is worth the price of admission .',
 'Review: rodriguez does a splendid job of racial profiling hollywood style--casting excellent latin actors of all ages--a trend long overdue .']

# process a batch of examples
>>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True)
# set number of processors
>>> ds = ds.map(add_prefix, num_proc=4)
```

#### фильтр[[datasets.Dataset.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, suffix_template: str = '_{rank:05d}_of_{num_proc:05d}', new_fingerprint: typing.Optional[str] = None, desc: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4231)

**Параметры:**

function (`Callable`) : Вызываемый объект с одной из следующих сигнатур:  - `function(example: Dict[str, Any]) -> bool`, если `batched=False` и `with_indices=False` и `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool`, если `batched=False` и `with_indices=True` и/или `with_rank=True` (один дополнительный аргумент для каждого) - `function(batch: Dict[str, List]) -> List[bool]`, если `batched=True` и `with_indices=False` и `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> List[bool]`, если `batched=True` и `with_indices=True` и/или `with_rank=True` (один дополнительный аргумент для каждого)  Если функция асинхронная, `filter` выполнит её параллельно. Если функция не задана, по умолчанию используется функция, всегда возвращающая `True`: `lambda x: True`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx[, rank]): ...`.

with_rank (`bool`, по умолчанию `False`) : Передать ранг процесса в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example[, idx], rank): ...`.

input_columns (`str` или `List[str]`, *необязательный*) : Столбцы, которые передаются в `function` как позиционные аргументы. Если указано `None`, в качестве одного аргумента передаётся `dict` с отображением на все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`.

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched = True`. Если `batched = False`, в `function` передаётся по одному примеру на партию. Если `batch_size <= 0` или `batch_size == None`, весь набор данных передаётся в `function` как одна партия.

keep_in_memory (`bool`, по умолчанию `False`) : Держать датасет в памяти, а не записывать его в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий текущие вычисления из `function`, использовать его вместо повторного вычисления.

cache_file_name (`str`, *необязательный*) : Укажите имя пути для файла кэша. Используется для хранения результатов вычислений вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

fn_kwargs (`dict`, *необязательный*) : Ключевые аргументы, передаваемые в `function`.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов для использования в многопроцессности. - Если `None` или `0`, многопроцессность не используется, и операция выполняется в основном процессе. - Если значение больше `1`, для параллельной обработки данных используются один или несколько рабочих процессов. Примечание: Функция, передаваемая в `map()`, должна быть сериализуемой (picklable), чтобы многопроцессность работала корректно (т. е. предпочтительнее использовать функции, определённые на верхнем уровне модуля, а не внутри другой функции или класса).

suffix_template (`str`) : Если указано `cache_file_name`, этот суффикс будет добавлен в конец базового имени каждого файла. Например, если `cache_file_name` равно `"processed.arrow"`, а `rank = 1` и `num_proc = 4`, то итоговый файл будет `"processed_00001_of_00004.arrow"` для суффикса по умолчанию (по умолчанию `_{rank:05d}_of_{num_proc:05d}`).

new_fingerprint (`str`, *необязательный*) : Новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

desc (`str`, *необязательный*, по умолчанию `None`) : Осмысленное описание, отображаемое рядом с индикатором прогресса во время фильтрации примеров.

Примените функцию фильтрации ко всем элементам таблицы партиями и обновите таблицу так, чтобы набор данных содержал только примеры, соответствующие функции фильтрации.

Если функция асинхронная, то `filter` будет выполнять её параллельно, с максимумом в тысячу одновременных вызовов (настраивается). Рекомендуется использовать `asyncio.Semaphore` в вашей функции, если вы хотите задать максимальное количество операций, которые могут выполняться одновременно.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.filter(lambda x: x["label"] == 1)
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 533
})
```

#### выбрать[[datasets.Dataset.select]]

```python
select(indices: Iterable, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4458)

**Параметры:**

indices (`range`, `list`, `iterable`, `ndarray` или `Series`) : Диапазон, список или одномерный массив целочисленных индексов для индексирования. Если индексы соответствуют непрерывному диапазону, таблица Arrow просто нарезается. Однако передача списка индексов, которые не являются непрерывными, создает отображение индексов, что значительно менее эффективно, но все же быстрее, чем пересоздание таблицы Arrow из требуемых строк.

keep_in_memory (`bool`, по умолчанию `False`) : Держать отображение индексов в памяти, а не записывать его в файл кэша.

indices_cache_file_name (`str`, *необязательный*, по умолчанию `None`) : Укажите имя пути для файла кэша. Используется для хранения индексов отображения вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

new_fingerprint (`str`, *необязательный*, по умолчанию `None`) : новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

Создайте новый набор данных, выбрав строки в соответствии со списком/массивом индексов.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.select(range(4))
>>> ds
Dataset({
    features: ['text', 'label'],
    num_rows: 4
})
```

#### sort[[datasets.Dataset.sort]]

```python
sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4799)

**Параметры:**

column_names (`Union[str, Sequence[str]]`) : Имя(я) столбца(ов) для сортировки.

reverse (`Union[bool, Sequence[bool]]`, по умолчанию `False`) : Если `True`, сортировка выполняется по убыванию, а не по возрастанию. Если указано одно значение bool, оно применяется к сортировке всех имён столбцов. В противном случае необходимо предоставить список значений bool той же длины и в том же порядке, что и column_names.

null_placement (`str`, по умолчанию `at_end`) : Размещать значения `None` в начале, если указано `at_start` или `first`, или в конце, если указано `at_end` или `last`

keep_in_memory (`bool`, по умолчанию `False`) : Хранить отсортированные индексы в памяти, а не записывать их в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий отсортированные индексы, используйте его вместо повторного вычисления.

indices_cache_file_name (`str`, *необязательный*, по умолчанию `None`) : Укажите имя пути для файла кэша. Используется для хранения отсортированных индексов вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Более высокое значение приводит к меньшим файлам кэша, более низкое значение потребляет меньше временной памяти.

new_fingerprint (`str`, *необязательный*, по умолчанию `None`) : новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования

Создайте новый набор данных, отсортированный по одному или нескольким столбцам.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes', split='validation')
>>> ds['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> sorted_ds = ds.sort('label')
>>> sorted_ds['label'][:10]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False])
>>> another_sorted_ds['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
```

#### shuffle[[datasets.Dataset.shuffle]]

```python
shuffle(seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4927)

**Параметры:**

seed (`int`, *optional*) : Значение seed для инициализации стандартного BitGenerator, если `generator=None`. Если указано `None`, то непредсказуемая энтропия будет получена из ОС. Если передано значение типа `int` или `array_like[ints]`, оно будет передано в SeedSequence для вывода начального состояния BitGenerator.

generator (`numpy.random.Generator`, *optional*) : Генератор случайных чисел Numpy, используемый для вычисления перестановки строк набора данных. Если `generator=None` (по умолчанию), используется `np.random.default_rng` (генератор битов по умолчанию (PCG64) в NumPy).

keep_in_memory (`bool`, по умолчанию `False`) : Хранить перемешанные индексы в памяти, а не записывать их в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий перемешанные индексы, используйте его вместо повторного вычисления.

indices_cache_file_name (`str`, *необязательный*) : Укажите имя пути для файла кэша. Используется для хранения перемешанных индексов вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

new_fingerprint (`str`, *необязательный*, по умолчанию `None`) : новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования.

Создайте новый Dataset, в котором строки перемешаны.

В настоящее время перемешивание использует генераторы случайных чисел NumPy. Вы можете передать экземпляр NumPy BitGenerator для использования или значение seed для инициализации генератора случайных чисел по умолчанию в NumPy (PCG64).

Shuffling берёт список индексов `[0:len(my_dataset)]` и перемешивает его, чтобы создать отображение индексов. Однако как только ваш [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) получает отображение индексов, скорость может снизиться в 10 раз. Это происходит из-за дополнительного шага получения индекса строки для чтения с использованием отображения индексов, и, что наиболее важно, вы больше не читаете непрерывные блоки данных. Чтобы восстановить скорость, вам нужно будет снова переписать весь набор данных на диске с помощью [Dataset.flatten_indices()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.flatten_indices), что удаляет отображение индексов.

В зависимости от размера набора данных это может занять много времени:

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

В этом случае мы рекомендуем перейти на [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset) и использовать его быстрый метод приблизительного перемешивания [IterableDataset.shuffle()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.shuffle).

Он лишь перемешивает порядок фрагментов и добавляет буфер перемешивания к вашему набору данных, что позволяет поддерживать оптимальную скорость работы с ним:

```python
my_iterable_dataset = my_dataset.to_iterable_dataset(num_shards=128)
for example in enumerate(my_iterable_dataset):  # fast
    pass

shuffled_iterable_dataset = my_iterable_dataset.shuffle(seed=42, buffer_size=100)

for example in enumerate(shuffled_iterable_dataset):  # as fast as before
    pass
```

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

# set a seed
>>> shuffled_ds = ds.shuffle(seed=42)
>>> shuffled_ds['label'][:10]
[1, 0, 1, 1, 0, 0, 0, 0, 0, 0]
```

#### пропустить[[datasets.Dataset.skip]]

```python
skip(n: int)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4711)

**Параметры:**

n (`int`) : Количество элементов, которые нужно пропустить.

Создайте новый [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset), который пропускает первые `n` элементов.

Пример:

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

#### take[[datasets.Dataset.take]]

```python
take(n: int)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4773)

**Параметры:**

n (`int`) : Количество элементов для извлечения.

Создайте новый [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) только с первыми `n` элементами.

Пример:

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

#### train_test_split[[datasets.Dataset.train_test_split]]

```python
train_test_split(test_size: typing.Union[float, int, NoneType] = None, train_size: typing.Union[float, int, NoneType] = None, shuffle: bool = True, stratify_by_column: typing.Optional[str] = None, seed: typing.Optional[int] = None, generator: typing.Optional[numpy.random._generator.Generator] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, train_indices_cache_file_name: typing.Optional[str] = None, test_indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, train_new_fingerprint: typing.Optional[str] = None, test_new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5064)

**Параметры:**

test_size (`Union[float, int, None]`, *необязательный*) : Размер тестовой выборки. Если `float`, значение должно находиться в диапазоне от `0.0` до `1.0` и указывать долю датасета, попадающую в тестовую выборку. Если `int`, указывает абсолютное количество тестовых образцов. Если `None`, значение устанавливается как дополнение к размеру обучающей выборки. Если `train_size` также равно `None`, оно будет установлено в `0.25`.

train_size (`Union[float, int, None]`, *необязательный*) : Размер обучающей выборки. Если `float`, значение должно находиться в диапазоне от `0.0` до `1.0` и указывать долю набора данных, включаемую в обучающую выборку. Если `int`, указывает абсолютное количество обучающих примеров. Если `None`, значение автоматически устанавливается как дополнение к размеру тестовой выборки.

shuffle (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли перемешивать данные перед разделением.

stratify_by_column (`str`, *необязательный*, по умолчанию `None`) : Имя столбца с метками, используемого для стратифицированного разбиения данных.

seed (`int`, *optional*) : Значение seed для инициализации стандартного BitGenerator, если `generator=None`. Если указано `None`, то непредсказуемая энтропия будет получена из ОС. Если передано значение типа `int` или `array_like[ints]`, оно будет передано в SeedSequence для вывода начального состояния BitGenerator.

generator (`numpy.random.Generator`, *optional*) : Генератор случайных чисел Numpy, используемый для вычисления перестановки строк набора данных. Если `generator=None` (по умолчанию), используется `np.random.default_rng` (генератор битов по умолчанию (PCG64) в NumPy).

keep_in_memory (`bool`, по умолчанию `False`) : Хранить индексы разбиений в памяти, а не записывать их в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, хранящий индексы разбиений, используйте его вместо повторного вычисления.

train_cache_file_name (`str`, *необязательный*) : Укажите имя пути для файла кэша. Используется для хранения индексов обучающей выборки вместо автоматически сгенерированного имени файла кэша.

test_cache_file_name (`str`, *необязательный*) : Укажите имя пути для файла кэша. Используется для хранения индексов тестовой выборки вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

train_new_fingerprint (`str`, *необязательный*, по умолчанию `None`) : новый отпечаток обучающей выборки после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования

test_new_fingerprint (`str`, *необязательный*, по умолчанию `None`) : новый отпечаток тестового набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования

Возвращает словарь ([datasets.DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)) с двумя случайными подмножествами для обучения и тестирования (`train` и `test` — разбиения `Dataset`). Разбиения создаются из набора данных в соответствии с параметрами `test_size`, `train_size` и `shuffle`.

Этот метод похож на `train_test_split` из scikit-learn.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation")
>>> ds = ds.train_test_split(test_size=0.2, shuffle=True)
DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 852
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 214
    })
})

# set a seed
>>> ds = ds.train_test_split(test_size=0.2, seed=42)

# stratified split
>>> ds = load_dataset("stanfordnlp/imdb",split="train")
Dataset({
    features: ['text', 'label'],
    num_rows: 25000
})
>>> ds = ds.train_test_split(test_size=0.2, stratify_by_column="label")
DatasetDict({
    train: Dataset({
        features: ['text', 'label'],
        num_rows: 20000
    })
    test: Dataset({
        features: ['text', 'label'],
        num_rows: 5000
    })
})
```

#### shard[[datasets.Dataset.shard]]

```python
shard(num_shards: int, index: int, contiguous: bool = True, keep_in_memory: bool = False, indices_cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5347)

**Параметры:**

num_shards (`int`) : Количество фрагментов, на которые следует разделить набор данных.

index (`int`) : Какой шунт выбрать и вернуть.

contiguous : (`bool`, по умолчанию `True`): следует ли выбирать непрерывные блоки индексов для шардов.

keep_in_memory (`bool`, по умолчанию `False`) : Держать датасет в памяти, а не записывать его в файл кэша.

indices_cache_file_name (`str`, *необязательный*) : Укажите имя пути для файла кэша. Используется для хранения индексов каждого шарда вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Касается только отображения индексов. Количество индексов на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений при обработке, более низкое значение потребляет меньше временной памяти во время выполнения `map`.

Возвращает `index`-й фрагмент из набора данных, разделённого на `num_shards` частей.

Это детерминированное разбиение на части. `dataset.shard(n, i)` делит набор данных на непрерывные фрагменты, поэтому после обработки их легко снова объединить. Если `len(dataset) % n == l`, то первые `l` наборов данных имеют длину `(len(dataset) // n) + 1`, а остальные — длину `(len(dataset) // n)`. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` возвращает набор данных с тем же порядком элементов, что и в исходном.

Примечание: n должно быть меньше или равно количеству элементов в наборе данных `len(dataset)`.

С другой стороны, `dataset.shard(n, i, contiguous=False)` содержит все элементы набора данных, для которых индекс по модулю `n = i`.

Убедитесь, что операция разделения на шарды выполняется до применения любого оператора, использующего случайность (например, `shuffle`). Лучше всего использовать оператор разделения на шарды на раннем этапе конвейера обработки данных.

Пример:

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

#### repeat[[datasets.Dataset.repeat]]

```python
repeat(num_times: int)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4741)

**Параметры:**

num_times (`int`) : Количество повторений набора данных.

Создайте новый [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset), который повторяет базовый набор данных `num_times` раз.

Как и в случае с itertools.repeat, повторение один раз просто возвращает полный набор данных.

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

#### to_tf_dataset[[datasets.Dataset.to_tf_dataset]]

```python
to_tf_dataset(batch_size: typing.Optional[int] = None, columns: typing.Union[str, list[str], NoneType] = None, shuffle: bool = False, collate_fn: typing.Optional[typing.Callable] = None, drop_remainder: bool = False, collate_fn_args: typing.Optional[dict[str, typing.Any]] = None, label_cols: typing.Union[str, list[str], NoneType] = None, prefetch: bool = True, num_workers: int = 0, num_test_batches: int = 20)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L342)

**Параметры:**

batch_size (`int`, *optional*) : Размер батчей, загружаемых из набора данных. По умолчанию `None`, что означает, что набор данных не будет разбит на батчи, но возвращенный набор данных можно разбить на батчи позже с помощью `tf_dataset.batch(batch_size)`.

columns (`List[str]` или `str`, *необязательный*) : Столбец(ы) датасета для загрузки в `tf.data.Dataset`. Можно использовать имена столбцов, созданные `collate_fn`, которые отсутствуют в исходном датасете.

shuffle(`bool`, по умолчанию `False`) : Перемешивает порядок данных при загрузке. Рекомендуется `True` для обучения, `False` для валидации/оценки.

drop_remainder(`bool`, по умолчанию `False`) : Отбрасывает последний неполный батч при загрузке. Гарантирует, что все батчи, возвращаемые набором данных, будут иметь одинаковую длину по измерению батча.

collate_fn(`Callable`, *необязательный*) : функция или вызываемый объект (например, `DataCollator`), который объединяет списки образцов в пакет.

collate_fn_args (`Dict`, *необязательный*) : Необязательный `dict` с аргументами по именам, которые передаются в `collate_fn`.

label_cols (`List[str]` или `str`, по умолчанию `None`) : Столбец(ы) набора данных, которые нужно загрузить в качестве меток. Обратите внимание, что многие модели вычисляют потерю самостоятельно, а не передают эту задачу Keras, в таком случае передача меток здесь является необязательной, при условии что они присутствуют во входных `columns`.

prefetch (`bool`, по умолчанию `True`) : Запускать ли загрузчик данных в отдельном потоке и поддерживать небольшой буфер батчей для обучения. Повышает производительность, позволяя загружать данные в фоновом режиме во время обучения модели.

num_workers (`int`, по умолчанию `0`) : Количество рабочих процессов для загрузки набора данных.

num_test_batches (`int`, по умолчанию `20`) : Количество батчей, используемых для определения сигнатуры вывода набора данных. Чем больше это число, тем точнее будет сигнатура, но тем дольше займёт создание набора данных.

**Возвращает:**

`tf.data.Dataset`

Создайте `tf.data.Dataset` на основе базового Dataset. Этот `tf.data.Dataset` будет загружать и формировать батчи из Dataset и подходит для передачи в методы, такие как `model.fit()` или `model.predict()`. Датасет будет возвращать `dicts` как для входных данных, так и для меток, если только `dict` не содержит единственный ключ, в этом случае вместо него возвращается «сырой» `tf.Tensor`.

Пример:

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

#### push_to_hub[[datasets.Dataset.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None, append: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6177)

**Параметры:**

repo_id (`str`) : Идентификатор репозитория, в который выполняется отправка, в формате `<user>/<dataset_name>` или `<org>/<dataset_name>`. Также принимается `<dataset_name>`, в этом случае используется пространство имен текущего пользователя по умолчанию. Также может указываться путь внутри бакета, например `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`, по умолчанию "default") : Имя конфигурации (или подмножества) набора данных. По умолчанию "default".

set_default (`bool`, *необязательный*) : Указывает, следует ли устанавливать эту конфигурацию в качестве конфигурации по умолчанию. В противном случае конфигурацией по умолчанию является та, что называется "default".

split (`str`, *необязательный*) : Имя сплита, которое будет присвоено этому набору данных. По умолчанию — `self.split`.

data_dir (`str`, *необязательный*) : Имя каталога, который будет содержать загруженные файлы данных. По умолчанию используется `config_name`, если он отличается от "default", иначе "data".

commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию — `"Upload dataset"`.

commit_description (`str`, *необязательный*) : Описание коммита, который будет создан. Кроме того, описание PR, если PR будет создан (`create_pr` равно True).

private (`bool`, *optional*) : Указывает, нужно ли сделать репозиторий приватным. Если `None` (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.

token (`str`, *необязательный*) : Необязательный токен аутентификации для Hugging Face Hub. Если токен не передан, по умолчанию будет использован токен, сохранённый локально при входе с помощью `hf auth login`. Если токен не передан и пользователь не вошёл в систему, будет выброшена ошибка.

revision (`str`, *необязательный*) : Ветка, в которую будут отправлены загруженные файлы. По умолчанию используется ветка `"main"`.

create_pr (`bool`, *необязательный*, по умолчанию `False`) : Создавать ли PR с загруженными файлами или коммитить изменения напрямую.

max_shard_size (`int` или `str`, *необязательный*, по умолчанию `"500MB"`) : Максимальный размер фрагментов набора данных, загружаемых в hub. Если указано в виде строки, должно представлять собой цифры, за которыми следует единица измерения (например, `"5MB"`).

num_shards (`int`, *необязательный*) : Количество шардов для записи. По умолчанию количество шардов зависит от `max_shard_size`.

embed_external_files (`bool`, по умолчанию `True`) : Встраивать ли байты файлов в шарды. В частности, перед отправкой для полей следующих типов будут выполнены следующие действия: - [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) и [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image): удалить информацию о локальном пути и встроить содержимое файла в файлы Parquet.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов при подготовке и загрузке набора данных. Это полезно, если набор данных состоит из множества образцов или медиафайлов для встраивания. Использует контекст "spawn" для работы с hf_xet, rust-клиентом для быстрой загрузки на HF. Многопроцессность по умолчанию отключена.

append (`bool`, по умолчанию `False`) : Добавляет строки к существующим разбивкам, сохраняя их признаки и строки. Скачивается и расширяется только последний Parquet-шард в порядке отображения карточки, среди всех указанных каталогов. Если его размер превысит `max_shard_size`, он сохраняется, а новые строки записываются в новые шарды. С помощью `num_shards` указывается общее количество шардов в разбивке после добавления; оно не может быть меньше существующего количества. Новые или переименованные шарды используют `data_dir`. Другие разбивки и конфигурации сохраняются. Поддерживается только для репозиториев датасетов.

**Возвращает:**

huggingface_hub.CommitInfo

Отправляет набор данных на хаб в формате Parquet. Набор данных отправляется с помощью HTTP-запросов, поэтому не требуется установка git или git-lfs.

Полученные файлы Parquet по умолчанию являются самодостаточными. Если ваш набор данных содержит данные [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) или [Video](/docs/datasets/main/ru/package_reference/main_classes#datasets.Video), файлы Parquet будут хранить байты ваших изображений или аудиофайлов. Вы можете отключить это, установив `embed_external_files` в `False`.

Пример:

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

Если ваш набор данных содержит несколько разбиений (например, train/validation/test):

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

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

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

#### save_to_disk[[datasets.Dataset.save_to_disk]]

```python
save_to_disk(dataset_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1809)

**Параметры:**

dataset_path (`path-like`) : Path (например, `dataset/train`) или удалённый URI (например, `s3://my-bucket/dataset/train`) каталога набора данных, в котором будет сохранён набор данных.

max_shard_size (`int` или `str`, *необязательный*, по умолчанию `"500MB"`) : Максимальный размер фрагментов набора данных, сохраняемых в файловую систему. Если значение указано в виде строки, оно должно состоять из цифр, за которыми следует единица измерения (например, `"50MB"`).

num_shards (`int`, *optional*) : Количество шардов для записи. По умолчанию количество шардов зависит от `max_shard_size` и `num_proc`.

num_proc (`int`, *optional*) : Количество процессов при загрузке и генерации набора данных локально. Многопоточность отключена по умолчанию.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

Сохраняет набор данных в каталог набора данных или в файловую систему с использованием любой реализации `fsspec.spec.AbstractFileSystem`.

Для данных [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) и [Video](/docs/datasets/main/ru/package_reference/main_classes#datasets.Video):

Все данные Image(), Audio() и Video() хранятся в файлах arrow. Если вы хотите хранить пути или URL, используйте тип Value("string").

Пример:

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

#### load_from_disk[[datasets.Dataset.load_from_disk]]

```python
load_from_disk(dataset_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L2017)

**Параметры:**

dataset_path (`path-like`) : Path (например, `"dataset/train"`) или удалённый URI (например, `"s3//my-bucket/dataset/train"`) каталога набора данных, из которого будет загружен набор данных.

keep_in_memory (`bool`, по умолчанию `None`) : Копировать ли датасет в оперативную память. Если `None`, датасет не будет скопирован в оперативную память, если только это явно не включено путём установки `datasets.config.IN_MEMORY_MAX_SIZE` в ненулевое значение. Подробнее см. в разделе [улучшение производительности](../cache#improve-performance).

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) или [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

- Если `dataset_path` — это путь к каталогу набора данных, то запрашиваемый набор данных.
- Если `dataset_path` — это путь к каталогу словаря датасета, возвращается `datasets.DatasetDict` с каждым сплитом.

Загружает набор данных, ранее сохранённый с помощью `save_to_disk`, из каталога набора данных или из файловой системы с использованием любой реализации `fsspec.spec.AbstractFileSystem`.

Пример:

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

#### flatten_indices[[datasets.Dataset.flatten_indices]]

```python
flatten_indices(keep_in_memory: bool = False, cache_file_name: typing.Optional[str] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, num_proc: typing.Optional[int] = None, new_fingerprint: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L4379)

**Параметры:**

keep_in_memory (`bool`, по умолчанию `False`) : Держать датасет в памяти, а не записывать его в файл кэша.

cache_file_name (`str`, *необязательный*, по умолчанию `None`) : Укажите имя пути для файла кэша. Используется для хранения результатов вычислений вместо автоматически сгенерированного имени файла кэша.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

features (`Optional[datasets.Features]`, по умолчанию `None`) : Использовать определённые [Features](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features) для сохранения файла кэша вместо автоматически сгенерированных.

disable_nullable (`bool`, по умолчанию `False`) : Разрешает использование значений null в таблице.

num_proc (`int`, необязательный параметр, по умолчанию `None`) : Максимальное количество процессов при генерации кэша. Уже закэшированные фрагменты загружаются последовательно

new_fingerprint (`str`, *необязательный*, по умолчанию `None`) : новый отпечаток набора данных после преобразования. Если `None`, новый отпечаток вычисляется с помощью хэша предыдущего отпечатка и аргументов преобразования

Создайте и закэшируйте новый Dataset, выровняв отображение индексов.

#### to_csv[[datasets.Dataset.to_csv]]

```python
to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5424)

**Параметры:**

path_or_buf (`PathLike` или `FileOrBuffer`) : Путь к файлу (например, `file.csv`), удалённый URI (например, `hf://datasets/username/my_dataset_name/data.csv`) или объект BinaryIO, в который набор данных будет сохранён в указанном формате.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

num_proc (`int`, *optional*) : Количество процессов для многопроцессности. По умолчанию многопроцессность не используется. В этом случае `batch_size` по умолчанию принимает значение `datasets.config.DEFAULT_MAX_BATCH_SIZE`, но при наличии достаточных вычислительных ресурсов вы можете увеличить его в 5 или 10 раз.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

- ****to_csv_kwargs** (дополнительные именованные аргументы): параметры, передаваемые в [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) из pandas. Теперь, если `index` не указан, по умолчанию используется `False`. Если вы хотите записать индекс, передайте `index=True` и задайте имя столбца индекса, передав `index_label`.

**Возвращает:** `int`

Количество записанных символов или байтов.

Экспортирует набор данных в csv

Пример:

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

#### to_pandas[[datasets.Dataset.to_pandas]]

```python
to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5623)

**Параметры:**

batch_size (`int`, *optional*) : размер (количество строк) батчей, если `batched` равно `True`. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

batched (`bool`) : Установите `True`, чтобы вернуть генератор, выдающий датасет батчами по `batch_size` строк. По умолчанию `False` (возвращает весь датасет сразу).

**Возвращает:**

`pandas.DataFrame` или `Iterator[pandas.DataFrame]`

Возвращает набор данных в виде `pandas.DataFrame`. Также может возвращать генератор для больших наборов данных.

Пример:

```py
>>> ds.to_pandas()
```

#### to_dict[[datasets.Dataset.to_dict]]

```python
to_dict(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5483)

**Параметры:**

batch_size (`int`, *optional*) : размер (количество строк) батчей, если `batched` равно `True`. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

batched (`bool`) : Установите `True`, чтобы вернуть генератор, выдающий датасет батчами по `batch_size` строк. По умолчанию `False` (возвращает весь датасет сразу).

**Возвращает:**

`dict` или `Iterator[dict]`

Возвращает набор данных в виде словаря Python. Также может возвращать генератор для больших наборов данных.

Пример:

```py
>>> ds.to_dict()
```

#### to_json[[datasets.Dataset.to_json]]

```python
to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5548)

**Параметры:**

path_or_buf (`PathLike` или `FileOrBuffer`) : Путь к файлу (например, `file.json`), удалённый URI (например, `hf://datasets/username/my_dataset_name/data.json`) или объект BinaryIO, в который набор данных будет сохранён в указанном формате.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

num_proc (`int`, *optional*) : Количество процессов для многопроцессности. По умолчанию многопроцессность не используется. В этом случае `batch_size` по умолчанию принимает значение `datasets.config.DEFAULT_MAX_BATCH_SIZE`, но при наличии достаточных вычислительных ресурсов вы можете увеличить его в 5 или 10 раз.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

- ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records".  <Changed version="2.11.0">  The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`.  If you would like to write the index, pass `index=True`.  

**Возвращает:** `int`

Количество записанных символов или байтов.

Экспортируйте набор данных в JSON Lines или JSON.

Формат вывода по умолчанию — [JSON Lines](https://jsonlines.org/). Чтобы экспортировать в [JSON](https://www.json.org), передайте аргумент `lines=False` и желаемое значение `orient`.

Пример:

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

#### to_parquet[[datasets.Dataset.to_parquet]]

```python
to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5725)

**Параметры:**

path_or_buf (`PathLike` или `FileOrBuffer`) : Путь к файлу (например, `file.parquet`), удалённый URI (например, `hf://datasets/username/my_dataset_name/data.parquet`) или объект BinaryIO, в который набор данных будет сохранён в указанном формате.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию настраивается на группы строк с максимальным размером в байтах без сжатия «100 МБ», определяемым `datasets.config.MAX_ROW_GROUP_SIZE`.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

- ****parquet_writer_kwargs** (дополнительные именованные аргументы): параметры для передачи в `pyarrow.parquet.ParquetWriter` PyArrow.

**Возвращает:** `int`

Количество записанных символов или байтов.

Экспортирует набор данных в parquet

Пример:

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

#### to_sql[[datasets.Dataset.to_sql]]

```python
to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, num_proc: typing.Optional[int] = None, **sql_writer_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5765)

**Параметры:**

name (`str`) : Имя таблицы SQL.

con (`str` или `sqlite3.Connection` или `sqlalchemy.engine.Connection` или `sqlalchemy.engine.Connection`) : строка [URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) или объект соединения SQLite3/SQLAlchemy, используемый для записи в базу данных.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

num_proc (`int`, *optional*) : Количество процессов для многопроцессности. По умолчанию многопроцессность не используется. В этом случае `batch_size` по умолчанию принимает значение `datasets.config.DEFAULT_MAX_BATCH_SIZE`, но при наличии достаточных вычислительных ресурсов вы можете увеличить его в 5 или 10 раз.

- ****sql_writer_kwargs** (дополнительные именованные аргументы): параметры, передаваемые в [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) из pandas. Теперь, если `index` не указан, по умолчанию используется значение `False`. Если вы хотите записать индекс, передайте `index=True` и задайте имя столбца индекса, передав `index_label`.

**Возвращает:** `int`

Количество записанных записей.

Экспортирует набор данных в SQL-базу данных.

Пример:

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

#### to_iterable_dataset[[datasets.Dataset.to_iterable_dataset]]

```python
to_iterable_dataset(num_shards: typing.Optional[int] = 1)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L5863)

**Параметры:**

num_shards (`int`, по умолчанию `1`) : Количество шардов, определяемых при создании итерируемого набора данных. Это особенно полезно для больших наборов данных, чтобы обеспечить корректное перемешивание, а также для быстрого параллельного чтения с помощью PyTorch DataLoader или в распределённых средах. Шарды определяются с помощью [datasets.Dataset.shard()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.shard): этот метод просто разбивает данные на части без записи на диск.

**Возвращает:**

[datasets.IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Получить [datasets.IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset) из набора данных в стиле map [datasets.Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset). Это эквивалентно загрузке набора данных в режиме потоковой обработки с помощью [datasets.load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset), но значительно быстрее, поскольку данные передаются из локальных файлов.

В отличие от наборов данных map-style, итерируемые наборы данных являются ленивыми и допускают только итерацию (например, с помощью цикла for). Поскольку они читаются последовательно в циклах обучения, итерируемые наборы данных значительно быстрее наборов данных map-style. Все преобразования, применяемые к итерируемым наборам данных, такие как фильтрация или обработка, выполняются на лету при начале итерации по набору данных.

Тем не менее, перемешать итерируемое датасет можно с помощью [datasets.IterableDataset.shuffle()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.shuffle). Это быстрое приближённое перемешивание, которое работает лучше всего, если у вас несколько шардов и вы указываете достаточно большой размер буфера.

Для достижения наилучшей производительности убедитесь, что в вашем наборе данных нет отображения индексов. Если оно присутствует, данные не читаются последовательно, что иногда может приводить к снижению скорости. Вы можете использовать `ds = ds.flatten_indices()`, чтобы записать ваш набор данных в последовательные блоки данных и получить оптимальную скорость перед переходом к итерируемому набору данных.

Пример:

Базовое использование:
```python
>>> ids = ds.to_iterable_dataset()
>>> for example in ids:
...     pass
```

С ленивой фильтрацией и обработкой:
```python
>>> ids = ds.to_iterable_dataset()
>>> ids = ids.filter(filter_fn).map(process_fn)  # will filter and process on-the-fly when you start iterating over the iterable dataset
>>> for example in ids:
...     pass
```

С шардированием для эффективного перемешивания:
```python
>>> ids = ds.to_iterable_dataset(num_shards=64)  # the dataset is split into 64 shards to be iterated over
>>> ids = ids.shuffle(buffer_size=10_000)  # will shuffle the shards order and use a shuffle buffer for fast approximate shuffling when you start iterating
>>> for example in ids:
...     pass
```

С использованием PyTorch DataLoader:
```python
>>> import torch
>>> ids = ds.to_iterable_dataset(num_shards=64)
>>> ids = ids.filter(filter_fn).map(process_fn)
>>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4)  # will assign 64 / 4 = 16 shards to each worker to load, filter and process when you start iterating
>>> for example in ids:
...     pass
```

С PyTorch DataLoader и перемешиванием:
```python
>>> import torch
>>> ids = ds.to_iterable_dataset(num_shards=64)
>>> ids = ids.shuffle(buffer_size=10_000)  # will shuffle the shards order and use a shuffle buffer when you start iterating
>>> dataloader = torch.utils.data.DataLoader(ids, num_workers=4)  # will assign 64 / 4 = 16 shards from the shuffled list of shards to each worker when you start iterating
>>> for example in ids:
...     pass
```

В распределённой конфигурации, такой как PyTorch DDP с PyTorch DataLoader и перемешиванием

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

С перемешиванием и несколькими эпохами:
```python
>>> ids = ds.to_iterable_dataset(num_shards=64)
>>> ids = ids.shuffle(buffer_size=10_000, seed=42)  # will shuffle the shards order and use a shuffle buffer when you start iterating
>>> for epoch in range(n_epochs):
...     ids.set_epoch(epoch)  # will use effective_seed = seed + epoch to shuffle the shards and for the shuffle buffer when you start iterating
...     for example in ids:
...         pass
```

Вы также можете использовать `IterableDataset.set_epoch()` при работе с PyTorch DataLoader или в распределённых средах.

#### add_faiss_index[[datasets.Dataset.add_faiss_index]]

```python
add_faiss_index(column: str, index_name: typing.Optional[str] = None, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = <class 'numpy.float32'>)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6437)

**Параметры:**

column (`str`) : Столбец векторов, которые нужно добавить в индекс.

index_name (`str`, *необязательный*) : `index_name`/идентификатор индекса. Это `index_name`, который используется для вызова [get_nearest_examples()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.get_nearest_examples) или [search()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.search). По умолчанию соответствует `column`.

device (`Union[int, List[int]]`, *необязательный*) : Если передано положительное целое число, это индекс используемого GPU. Если передано отрицательное целое число, используются все GPU. Если передан список положительных целых чисел, выполняется только на указанных GPU. По умолчанию используется CPU.

string_factory (`str`, *необязательный*) : Передаётся в фабрику индексов Faiss для создания индекса. Класс индекса по умолчанию — `IndexFlat`.

metric_type (`int`, *необязательный*) : Тип метрики. Пример: `faiss.METRIC_INNER_PRODUCT` или `faiss.METRIC_L2`.

custom_index (`faiss.Index`, *optional*) : Пользовательский индекс Faiss, который вы уже создали и настроили под свои нужды.

batch_size (`int`) : Размер батча, используемый при добавлении векторов в `FaissIndex`. Значение по умолчанию — `1000`.

train_size (`int`, *optional*) : Если для индекса требуется шаг обучения, указывает, сколько векторов будет использовано для обучения индекса.

faiss_verbose (`bool`, по умолчанию `False`) : Включает подробный вывод для индекса Faiss.

dtype (`data-type`) : тип данных (dtype) индексируемых массивов numpy. По умолчанию `np.float32`.

Добавьте плотный индекс с помощью Faiss для быстрого поиска. По умолчанию индекс строится по векторам указанной колонки. Вы можете указать `device`, если хотите выполнять индексацию на GPU (`device` должен быть индексом GPU). Дополнительную информацию о Faiss можно найти здесь:

- Для [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory)

Пример:

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

>>> ds = datasets.load_dataset('community-datasets/crime_and_punish', split='train')
>>> # load index
>>> ds.load_faiss_index('embeddings', 'my_index.faiss')
>>> # query
>>> scores, retrieved_examples = ds.get_nearest_examples('embeddings', embed('my new query'), k=10)
```

#### add_faiss_index_from_external_arrays[[datasets.Dataset.add_faiss_index_from_external_arrays]]

```python
add_faiss_index_from_external_arrays(external_arrays: array, index_name: str, device: typing.Optional[int] = None, string_factory: typing.Optional[str] = None, metric_type: typing.Optional[int] = None, custom_index: typing.Optional[ForwardRef('faiss.Index')] = None, batch_size: int = 1000, train_size: typing.Optional[int] = None, faiss_verbose: bool = False, dtype = <class 'numpy.float32'>)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6517)

**Параметры:**

external_arrays (`np.array`) : Если вы хотите использовать массивы извне библиотеки для индекса, вы можете установить `external_arrays`. Вместо массивов в указанном `column` будет использоваться `external_arrays` для создания индекса Faiss.

index_name (`str`) : `index_name`/идентификатор индекса. Это `index_name`, который используется для вызова [get_nearest_examples()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.get_nearest_examples) или [search()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.search).

device (Необязательный `Union[int, List[int]]`, *optional*) : Если передано положительное целое число, это индекс используемого GPU. Если передано отрицательное целое число, используются все GPU. Если передан список положительных целых чисел, выполняется только на указанных GPU. По умолчанию используется CPU.

string_factory (`str`, *необязательный*) : Передаётся в фабрику индексов Faiss для создания индекса. Класс индекса по умолчанию — `IndexFlat`.

metric_type (`int`, *необязательный*) : Тип метрики. Пример: `faiss.faiss.METRIC_INNER_PRODUCT` или `faiss.METRIC_L2`.

custom_index (`faiss.Index`, *optional*) : Пользовательский индекс Faiss, который вы уже создали и настроили под свои нужды.

batch_size (`int`, *optional*) : Размер батча, используемый при добавлении векторов в FaissIndex. Значение по умолчанию — 1000.

train_size (`int`, *optional*) : Если для индекса требуется шаг обучения, указывает, сколько векторов будет использовано для обучения индекса.

faiss_verbose (`bool`, по умолчанию False) : Включает подробный вывод для индекса Faiss.

dtype (`numpy.dtype`) : тип данных (dtype) индексируемых массивов numpy. По умолчанию — np.float32.

Добавьте плотный индекс с помощью Faiss для быстрого поиска. Индекс создаётся на основе векторов из `external_arrays`. При необходимости можно указать `device` для запуска на GPU (`device` должен быть индексом GPU). Дополнительную информацию о Faiss можно найти здесь:

- Для [string factory](https://github.com/facebookresearch/faiss/wiki/The-index-factory)

#### save_faiss_index[[datasets.Dataset.save_faiss_index]]

```python
save_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L535)

**Параметры:**

index_name (`str`) : index_name/идентификатор индекса. Это index_name, который используется для вызова `.get_nearest` или `.search`.

file (`str`) : Путь к сериализованному индексу faiss на диске или удалённый URI (например, `"s3://my-bucket/index.faiss"`).

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

Сохранить FaissIndex на диск.

#### load_faiss_index[[datasets.Dataset.load_faiss_index]]

```python
load_faiss_index(index_name: str, file: typing.Union[str, pathlib.PurePath], device: typing.Union[int, list[int], NoneType] = None, storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L553)

**Параметры:**

index_name (`str`) : index_name/идентификатор индекса. Это index_name, который используется для вызова `.get_nearest` или `.search`.

file (`str`) : Путь к сериализованному индексу faiss на диске или удалённый URI (например, `"s3://my-bucket/index.faiss"`).

device (Необязательный `Union[int, List[int]]`) : Если передано положительное целое число, это индекс используемого GPU. Если передано отрицательное целое число, используются все GPU. Если передан список положительных целых чисел, выполняется только на указанных GPU. По умолчанию используется CPU.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

Загрузите FaissIndex с диска.

Если вам требуется дополнительная настройка, вы можете получить доступ к объекту индекса faiss, выполнив `.get_index(index_name).faiss_index`, чтобы адаптировать его под свои задачи.

#### add_elasticsearch_index[[datasets.Dataset.add_elasticsearch_index]]

```python
add_elasticsearch_index(column: str, index_name: typing.Optional[str] = None, host: typing.Optional[str] = None, port: typing.Optional[int] = None, es_client: typing.Optional[ForwardRef('elasticsearch.Elasticsearch')] = None, es_index_name: typing.Optional[str] = None, es_index_config: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6576)

**Параметры:**

column (`str`) : Столбец документов, которые нужно добавить в индекс.

index_name (`str`, *необязательный*) : `index_name`/идентификатор индекса. Это имя индекса, которое используется для вызова [get_nearest_examples()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.get_nearest_examples) или [search()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.search). По умолчанию соответствует `column`.

host (`str`, *необязательный*, по умолчанию `localhost`) : Хост, на котором запущен ElasticSearch.

port (`str`, *необязательный*, по умолчанию `9200`) : Порт, на котором работает ElasticSearch.

es_client (`elasticsearch.Elasticsearch`, *необязательный*) : клиент elasticsearch, используемый для создания индекса, если host и port равны `None`.

es_index_name (`str`, *необязательный*) : Имя индекса elasticsearch, используемое для создания индекса.

es_index_config (`dict`, *необязательный*) : Конфигурация индекса elasticsearch. Конфигурация по умолчанию: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ```

Добавьте текстовый индекс с помощью ElasticSearch для быстрого поиска. Это выполняется на месте.

Пример:

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

#### load_elasticsearch_index[[datasets.Dataset.load_elasticsearch_index]]

```python
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)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L637)

**Параметры:**

index_name (`str`) : `index_name`/идентификатор индекса. Это имя индекса, которое используется для вызова `get_nearest` или `search`.

es_index_name (`str`) : Имя индекса elasticsearch для загрузки.

host (`str`, *необязательный*, по умолчанию `localhost`) : Хост, на котором запущен ElasticSearch.

port (`str`, *необязательный*, по умолчанию `9200`) : Порт, на котором работает ElasticSearch.

es_client (`elasticsearch.Elasticsearch`, *необязательный*) : клиент elasticsearch, используемый для создания индекса, если host и port равны `None`.

es_index_config (`dict`, *необязательный*) : Конфигурация индекса elasticsearch. Конфигурация по умолчанию: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ```

Загрузите существующий текстовый индекс с помощью ElasticSearch для быстрого поиска.

#### list_indexes[[datasets.Dataset.list_indexes]]

```python
list_indexes()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L438)

Перечислите `colindex_nameumns`/идентификаторы всех подключенных индексов.

#### get_index[[datasets.Dataset.get_index]]

```python
get_index(index_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L442)

**Параметры:**

index_name (`str`) : Имя индекса.

**Возвращает:**

`BaseIndex`

Перечислите `index_name`/идентификаторы всех подключенных индексов.

#### drop_index[[datasets.Dataset.drop_index]]

```python
drop_index(index_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L684)

**Параметры:**

index_name (`str`) : `index_name`/идентификатор индекса.

Удалите индекс с указанной колонкой.

#### поиск[[datasets.Dataset.search]]

```python
search(index_name: str, query: typing.Union[str, <built-in function array>], k: int = 10, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L693)

**Параметры:**

index_name (`str`) : Имя/идентификатор индекса.

query (`Union[str, np.ndarray]`) : Запрос в виде строки, если `index_name` — текстовый индекс, или в виде массива numpy, если `index_name` — векторный индекс.

k (`int`) : Количество примеров для получения.

**Возвращает:** `(scores, indices)`

Кортеж `(scores, indices)`, где:
- **scores** (`List[List[float]`): оценки релевантности, полученные из FAISS (по умолчанию `IndexFlatL2`) или ElasticSearch для найденных примеров
- **indices** (`List[List[int]]`): индексы извлечённых примеров

Найдите индексы ближайших примеров в наборе данных к запросу.

#### search_batch[[datasets.Dataset.search_batch]]

```python
search_batch(index_name: str, queries: typing.Union[list[str], <built-in function array>], k: int = 10, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L713)

**Параметры:**

index_name (`str`) : `index_name`/идентификатор индекса.

queries (`Union[List[str], np.ndarray]`) : Запросы в виде списка строк, если `index_name` — текстовый индекс, или в виде массива numpy, если `index_name` — векторный индекс.

k (`int`) : Количество примеров, извлекаемых на каждый запрос.

**Возвращает:** `(total_scores, total_indices)`

Кортеж `(total_scores, total_indices)`, где:
- **total_scores** (`List[List[float]`): оценки релевантности, полученные из FAISS (по умолчанию `IndexFlatL2`) или ElasticSearch для каждого запроса
- **total_indices** (`List[List[int]]`): индексы найденных примеров для каждого запроса

Найдите индексы ближайших примеров в наборе данных к запросу.

#### get_nearest_examples[[datasets.Dataset.get_nearest_examples]]

```python
get_nearest_examples(index_name: str, query: typing.Union[str, <built-in function array>], k: int = 10, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L735)

**Параметры:**

index_name (`str`) : index_name/идентификатор индекса.

query (`Union[str, np.ndarray]`) : Запрос в виде строки, если `index_name` — текстовый индекс, или в виде массива numpy, если `index_name` — векторный индекс.

k (`int`) : Количество примеров для получения.

**Возвращает:** `(scores, examples)`

Кортеж `(scores, examples)`, где:
- **scores** (`List[float]`): оценки релевантности, полученные из FAISS (по умолчанию `IndexFlatL2`) или ElasticSearch для найденных примеров
- **examples** (`dict`): полученные примеры

Найдите в наборе данных примеры, наиболее близкие к запросу.

#### get_nearest_examples_batch[[datasets.Dataset.get_nearest_examples_batch]]

```python
get_nearest_examples_batch(index_name: str, queries: typing.Union[list[str], <built-in function array>], k: int = 10, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/search.py#L759)

**Параметры:**

index_name (`str`) : `index_name`/идентификатор индекса.

queries (`Union[List[str], np.ndarray]`) : Запросы в виде списка строк, если `index_name` — текстовый индекс, или в виде массива numpy, если `index_name` — векторный индекс.

k (`int`) : Количество примеров, извлекаемых на каждый запрос.

**Возвращает:** `(total_scores, total_examples)`

Кортеж `(total_scores, total_examples)`, где:
- **total_scores** (`List[List[float]`): оценки релевантности, полученные из FAISS (по умолчанию `IndexFlatL2`) или ElasticSearch для каждого запроса
- **total_examples** (`List[dict]`): полученные примеры для каждого запроса

Найдите в наборе данных примеры, наиболее близкие к запросу.

#### info[[datasets.Dataset.info]]

```python
info()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L178)

Объект [DatasetInfo](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetInfo), содержащий все метаданные набора данных.

#### split[[datasets.Dataset.split]]

```python
split()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L183)

Объект [NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), соответствующий именованной части набора данных.

#### builder_name[[datasets.Dataset.builder_name]]

```python
builder_name()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L188)

#### цитирование[[datasets.Dataset.citation]]

```python
citation()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L192)

#### config_name[[datasets.Dataset.config_name]]

```python
config_name()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L196)

#### dataset_size[[datasets.Dataset.dataset_size]]

```python
dataset_size()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L200)

#### Описание[[datasets.Dataset.description]]

```python
description()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L204)

#### download_checksums[[datasets.Dataset.download_checksums]]

```python
download_checksums()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L208)

#### download_size[[datasets.Dataset.download_size]]

```python
download_size()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L212)

#### features[[datasets.Dataset.features]]

```python
features()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L813)

#### главная[[datasets.Dataset.homepage]]

```python
homepage()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L220)

#### лицензия[[datasets.Dataset.license]]

```python
license()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L224)

#### size_in_bytes[[datasets.Dataset.size_in_bytes]]

```python
size_in_bytes()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L228)

#### supervised_keys[[datasets.Dataset.supervised_keys]]

```python
supervised_keys()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L232)

#### версия[[datasets.Dataset.version]]

```python
version()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L236)

#### from_csv[[datasets.Dataset.from_csv]]

```python
from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1310)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (пути) к файлу (файлам) CSV.

split ([NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов при загрузке и локальной генерации набора данных. Это полезно, если набор данных состоит из нескольких файлов. Многопоточность отключена по умолчанию.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `pandas.read_csv`.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создание набора данных из файла(ов) CSV.

Читает файлы CSV, кэширует данные в формате Arrow на диске и возвращает Dataset из данных Arrow, отображённых в память, на диске.

Пример:

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

#### from_json[[datasets.Dataset.from_json]]

```python
from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, num_proc: typing.Optional[int] = None, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1450)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (или пути) к файлу (файлам) в формате JSON или JSON Lines.

split ([NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

field (`str`, *необязательный*) : Имя поля в JSON-файле, содержащем набор данных.

num_proc (`int`, *optional* по умолчанию `None`) : Количество процессов при загрузке и генерации набора данных локально. Это полезно, если набор данных состоит из нескольких файлов. Многопоточность отключена по умолчанию.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `JsonConfig`.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создание набора данных из файла или файлов в формате JSON или JSON Lines.

Прочитайте файлы JSON, закэшируйте данные в формате Arrow на диске и верните Dataset из данных Arrow, отображённых в память, на диске.

Пример:

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

#### from_parquet[[datasets.Dataset.from_parquet]]

```python
from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, num_proc: typing.Optional[int] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1509)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (пути) к файлу (файлам) Parquet.

split (`NamedSplit`, *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features (`Features`, *необязательный*) : Функции набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

columns (`List[str]`, *необязательный*) : Если не `None`, из файла будут прочитаны только эти столбцы. Имя столбца может быть префиксом вложенного поля, например, 'a' выберет 'a.b', 'a.c' и 'a.d.e'.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов при загрузке и локальной генерации набора данных. Это полезно, если набор данных состоит из нескольких файлов. Многопоточность отключена по умолчанию.

filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *необязательный*) : Возвращает только строки, соответствующие фильтру. Если возможно, предикат будет передан вниз, чтобы использовать информацию о партициях или внутренние метаданные, найденные в источнике данных, например, статистику Parquet. В противном случае фильтрует загруженные RecordBatches перед их возвратом.

fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *необязательный*) : Параметры, специфичные для сканирования фрагментов Parquet. Это особенно полезно для настройки буферизации и кэширования.

on_bad_files (`Literal["error", "warn", "skip"]`, *необязательный*, по умолчанию "error") : Указывает, что делать при обнаружении повреждённого файла (файла, который невозможно прочитать). Допустимые значения: * 'error' — вызывать исключение при обнаружении повреждённого файла. * 'warn' — выводить предупреждение при обнаружении повреждённого файла и пропускать его. * 'skip' — пропускать повреждённые файлы без вывода предупреждений или вызова исключений.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `ParquetConfig`.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создание набора данных из файла(ов) Parquet.

Читает файлы Parquet, кэширует данные в формате Arrow на диске и возвращает Dataset из данных Arrow, отображённых в память, на диске.

Пример:

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

Загрузка подмножества столбцов:

```python
>>> ds = Dataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"])
```

Эффективно фильтруйте данные, при необходимости пропуская целые файлы или группы строк:

```python
>>> filters = [("col_0", "==", 0)]
>>> ds = Dataset.from_parquet(parquet_files_list, filters=filters)
```

#### from_text[[datasets.Dataset.from_text]]

```python
from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, num_proc: typing.Optional[int] = None, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1606)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (пути) к текстовому файлу (файлам).

split (`NamedSplit`, *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features (`Features`, *необязательный*) : Функции набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов при загрузке и локальной генерации набора данных. Это полезно, если набор данных состоит из нескольких файлов. Многопоточность отключена по умолчанию.

keep_linebreaks : (`bool`, по умолчанию False): Сохранять ли переносы строк.

sample_by (`Literal["line", "paragraph", "document"]`, по умолчанию "line") : Загружать данные построчно, по абзацам или по документам. По умолчанию одна строка в наборе данных соответствует одной строке текста.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `TextConfig`.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создание набора данных из текстового файла или файлов.

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

Пример:

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

#### from_sql[[datasets.Dataset.from_sql]]

```python
from_sql(sql: typing.Union[str, ForwardRef('sqlalchemy.sql.Selectable')], con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L1734)

**Параметры:**

sql (`str` или `sqlalchemy.sql.Selectable`) : SQL-запрос для выполнения или имя таблицы.

con (`str` или `sqlite3.Connection` или `sqlalchemy.engine.Connection` или `sqlalchemy.engine.Connection`) : [строка URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls), используемая для создания подключения к базе данных, или объект подключения SQLite3/SQLAlchemy.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `SqlConfig`.

**Возвращает:**

[Набор данных](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset)

Создание набора данных из SQL-запроса или таблицы базы данных.

Запросите базу данных SQL, закэшируйте данные в формате Arrow на диске и верните Dataset из данных Arrow на диске, отображённых в память.

Пример:

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

> [!TIP]
> Возвращаемый набор данных может быть закэширован только в том случае, если `con` указан как строка URI.

#### align_labels_with_mapping[[datasets.Dataset.align_labels_with_mapping]]

```python
align_labels_with_mapping(label2id: dict, label_column: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L6698)

**Параметры:**

label2id (`dict`) : Соответствие между именами меток и их идентификаторами, с которым нужно привести в соответствие набор данных.

label_column (`str`) : Имя столбца с метками, по которому выполняется выравнивание.

Выровняйте сопоставление идентификаторов и названий меток в наборе данных с входным сопоставлением `label2id`. Это полезно, если вы хотите убедиться, что предсказанные моделью метки согласованы с набором данных. Выравнивание выполняется на основе названий меток в нижнем регистре.

Пример:

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

#### datasets.concatenate_datasets[[datasets.concatenate_datasets]]

```python
datasets.concatenate_datasets(dsets: list, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, axis: int = 0)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/combine.py#L168)

**Параметры:**

dsets (`List[datasets.Dataset]` или `List[datasets.IterableDataset]`) : Список датасетов для конкатенации.

info (`DatasetInfo`, *необязательный*) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, *необязательный*) : Имя сплита набора данных.

axis (`{0, 1}`, по умолчанию `0`) : Ось, по которой выполняется конкатенация, где `0` означает по строкам (вертикально), а `1` — по столбцам (горизонтально).

Соедините несколько наборов данных (источников) в один набор данных.

Используйте axis=0 для вертикального объединения (по умолчанию) или axis=1 для горизонтального объединения.

Примечание для итерируемых наборов данных:

* if axis=0, the resulting dataset's `num_shards` is the sum of each dataset's `num_shards`.
* if axis=1, результирующий набор данных содержит один (1) шард, чтобы не допустить рассинхронизации данных.
* if the datasets were split with [datasets.distributed.split_dataset_by_node()](/docs/datasets/main/ru/package_reference/main_classes#datasets.distributed.split_dataset_by_node), they must all be split the same way, and the resulting dataset keeps that split.

Пример:

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

#### datasets.interleave_datasets[[datasets.interleave_datasets]]

```python
datasets.interleave_datasets(datasets: list, probabilities: typing.Optional[list[float]] = None, seed: typing.Optional[int] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, stopping_strategy: typing.Literal['first_exhausted', 'all_exhausted', 'all_exhausted_without_replacement'] = 'first_exhausted')
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/combine.py#L18)

**Параметры:**

datasets (`List[Dataset]` или `List[IterableDataset]`) : список датасетов для чередования.

probabilities (`List[float]`, *необязательный*, по умолчанию `None`) : Если указано, новый набор данных формируется путём выборки примеров из одного источника за раз в соответствии с этими вероятностями.

seed (`int`, *необязательный*, по умолчанию `None`) : Случайное зерно, используемое для выбора источника для каждого примера.

info ([DatasetInfo](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetInfo), *optional*) : Информация о наборе данных, например, описание, цитирование и т. д.

split ([NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), *необязательный*) : Имя сплита набора данных.

stopping_strategy (`str`, по умолчанию `first_exhausted`) : В настоящее время предлагаются три стратегии: `first_exhausted`, `all_exhausted` и `all_exhausted_without_replacement`. По умолчанию `first_exhausted` является стратегией недообучения (undersampling), то есть формирование набора данных прекращается, как только в одном из наборов заканчиваются примеры. Если стратегия равна `all_exhausted`, используется стратегия переобучения (oversampling), то есть формирование набора данных прекращается, как только каждый пример из каждого набора был добавлен хотя бы один раз. При стратегии `all_exhausted_without_replacement` мы гарантируем, что каждый пример в каждом наборе извлекается только один раз. Обратите внимание, что при стратегии `all_exhausted` размер перемешанного набора данных может стать огромным: - без вероятностей результирующий набор будет содержать `max_length_datasets*nb_dataset` примеров. - с заданными вероятностями результирующий набор будет содержать больше примеров, если у некоторых наборов действительно низкая вероятность выбора.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) или [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Тип возвращаемого значения зависит от входного параметра `datasets`. `Dataset`, если на вход передан список объектов `Dataset`, и `IterableDataset`, если на вход передан список объектов `IterableDataset`.

Чередуйте несколько наборов данных (источников), чтобы получить единый набор данных. Новый набор данных формируется путём чередования источников для получения примеров.

Эту функцию можно использовать со списком объектов [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) или со списком объектов [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset).

- Если `probabilities` равно `None` (по умолчанию), новый набор данных формируется путём циклического перебора каждого источника для получения примеров.
- Если `probabilities` не равно `None`, новый набор данных формируется путём получения примеров из случайного источника по одному согласно заданным вероятностям.

Результирующий датасет завершается, когда один из исходных датасетов исчерпывает примеры, за исключением случая, когда `oversampling` равно `True`: тогда результирующий датасет завершается, когда все датасеты исчерпали примеры хотя бы один раз.

Примечание для итерируемых наборов данных:

* Значение `num_shards` результирующего набора данных равно минимальному значению `num_shards` среди всех исходных наборов, что обеспечивает хорошую параллельность. Если в некоторых наборах данных количество шардов очень мало, можно использовать [IterableDataset.reshard()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.reshard).
* В распределённой конфигурации или в рабочих процессах PyTorch DataLoader стратегия остановки применяется для каждого процесса. Поэтому стратегия "first_exhausted" для итерируемого набора данных с шардированием может сгенерировать меньше примеров в общей сложности (до 1 отсутствующего примера на поднабор данных на рабочий процесс).

Пример:

Для обычных наборов данных (map-style):

```python
>>> from datasets import Dataset, interleave_datasets
>>> d1 = Dataset.from_dict({"a": [0, 1, 2]})
>>> d2 = Dataset.from_dict({"a": [10, 11, 12]})
>>> d3 = Dataset.from_dict({"a": [20, 21, 22]})
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted")
>>> dataset["a"]
[10, 0, 11, 1, 2, 20, 12, 10, 0, 1, 2, 21, 0, 11, 1, 2, 0, 1, 12, 2, 10, 0, 22]
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42)
>>> dataset["a"]
[10, 0, 11, 1, 2]
>>> dataset = interleave_datasets([d1, d2, d3])
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22]
>>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted")
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22]
>>> d1 = Dataset.from_dict({"a": [0, 1, 2]})
>>> d2 = Dataset.from_dict({"a": [10, 11, 12, 13]})
>>> d3 = Dataset.from_dict({"a": [20, 21, 22, 23, 24]})
>>> dataset = interleave_datasets([d1, d2, d3])
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22]
>>> dataset = interleave_datasets([d1, d2, d3], stopping_strategy="all_exhausted")
>>> dataset["a"]
[0, 10, 20, 1, 11, 21, 2, 12, 22, 0, 13, 23, 1, 10, 24]
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42)
>>> dataset["a"]
[10, 0, 11, 1, 2]
>>> dataset = interleave_datasets([d1, d2, d3], probabilities=[0.7, 0.2, 0.1], seed=42, stopping_strategy="all_exhausted")
>>> dataset["a"]
[10, 0, 11, 1, 2, 20, 12, 13, ..., 0, 1, 2, 0, 24]
For datasets in streaming mode (iterable):

>>> from datasets import interleave_datasets
>>> d1 = load_dataset('allenai/c4', 'es', split='train', streaming=True)
>>> d2 = load_dataset('allenai/c4', 'fr', split='train', streaming=True)
>>> dataset = interleave_datasets([d1, d2])
>>> iterator = iter(dataset)
>>> next(iterator)
{'text': 'Comprar Zapatillas para niña en chancla con goma por...'}
>>> next(iterator)
{'text': 'Le sacre de philippe ier, 23 mai 1059 - Compte Rendu...'
```

#### datasets.distributed.split_dataset_by_node[[datasets.distributed.split_dataset_by_node]]

```python
datasets.distributed.split_dataset_by_node(dataset: ~DatasetType, rank: int, world_size: int, strategy: typing.Literal['auto', 'shards', 'examples'] = 'auto')
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/distributed.py#L10)

**Параметры:**

dataset ([Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) или [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)) : набор данных, который нужно разделить по узлам.

rank (`int`) : Ранг текущего узла.

world_size (`int`) : Общее количество узлов.

strategy (`str`, по умолчанию `"auto"`) : Способ разбиения итерируемого набора данных. Должно быть одним из `"auto"`, `"shards"` или `"examples"`. Наборы данных в стиле Map поддерживают только `"auto"`.

**Возвращает:** [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset) или [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Набор данных, который будет использоваться на узле с рангом `rank`.

Разделите набор данных для узла с рангом `rank` в пуле узлов размером `world_size`.

Для наборов данных в стиле карты:

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

Для итерируемых наборов данных:

Стратегия разбиения `strategy` может принимать значения `"auto"`, `"shards"` или `"examples"`:

* `"shards"`: шарды равномерно распределяются по узлам
* `"examples"`: каждый узел хранит 1 пример из `world_size`, пропуская остальные примеры
* `"auto"` (по умолчанию): использует `"shards"`, если количество шардов в наборе данных является делителем `world_size`
(то есть если `dataset.num_shards % world_size == 0`), что является наиболее оптимизированным вариантом. В противном случае используется `"examples"`.

> [!WARNING]
> Если вы перемешиваете итерируемое множество данных в распределённой конфигурации, убедитесь, что вы задали фиксированное значение `seed` в [IterableDataset.shuffle()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.shuffle)
таким образом, на каждом узле используется один и тот же перемешанный список фрагментов, чтобы определить, какие фрагменты узлу следует пропустить.

#### datasets.enable_caching[[datasets.enable_caching]]

```python
datasets.enable_caching()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L120)

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

Повторная загрузка набора данных возможна, поскольку файлы кэша именуются на основе отпечатка (fingerprint) набора данных, который обновляется после каждого преобразования.

Если отключено, библиотека больше не будет перезагружать файлы кэшированных наборов данных при применении преобразований к наборам данных. Более точно, если кэширование отключено:
- файлы кэша всегда пересоздаются
- файлы кэша записываются во временный каталог, который удаляется при закрытии сессии
- файлы кэша получают имена на основе случайного хэша, а не отпечатка данных
- используйте [save_to_disk()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.save_to_disk), чтобы сохранить преобразованный набор данных, иначе он будет удалён при закрытии сессии
- Кэширование не влияет на [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset). Если вы хотите создать набор данных с нуля, следует использовать
параметр `download_mode` в [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset).

#### datasets.disable_caching[[datasets.disable_caching]]

```python
datasets.disable_caching()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L141)

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

Повторная загрузка набора данных возможна, поскольку файлы кэша именуются на основе отпечатка (fingerprint) набора данных, который обновляется после каждого преобразования.

Если отключено, библиотека больше не будет перезагружать файлы кэшированных наборов данных при применении преобразований к наборам данных. Более точно, если кэширование отключено:
- файлы кэша всегда пересоздаются
- файлы кэша записываются во временный каталог, который удаляется при закрытии сессии
- файлы кэша получают имена на основе случайного хэша, а не отпечатка данных
- используйте [save_to_disk()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.save_to_disk), чтобы сохранить преобразованный набор данных, иначе он будет удалён при закрытии сессии
- Кэширование не влияет на [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset). Если вы хотите создать набор данных с нуля, следует использовать
параметр `download_mode` в [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset).

#### datasets.is_caching_enabled[[datasets.is_caching_enabled]]

```python
datasets.is_caching_enabled()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L162)

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

Повторная загрузка набора данных возможна, поскольку файлы кэша именуются на основе отпечатка (fingerprint) набора данных, который обновляется после каждого преобразования.

Если отключено, библиотека больше не будет перезагружать файлы кэшированных наборов данных при применении преобразований к наборам данных. Более точно, если кэширование отключено:
- файлы кэша всегда пересоздаются
- файлы кэша записываются во временный каталог, который удаляется при закрытии сессии
- файлы кэша получают имена на основе случайного хэша, а не отпечатка данных
- используйте [save_to_disk()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.save_to_disk), чтобы сохранить преобразованный набор данных, иначе он будет удалён при закрытии сессии
- Кэширование не влияет на [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset). Если вы хотите создать набор данных с нуля, следует использовать
параметр `download_mode` в [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset).

#### datasets.Column[[datasets.Column]]

```python
datasets.Column(source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')], column_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L662)

Итерируемый объект для конкретного столбца [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset).

Пример:

Итерация по значениям столбца "text" набора данных:

```python
for text in dataset["text"]:
    ...
```

Он также работает с вложенными столбцами:

```python
for source in dataset["metadata"]["source"]:
    ...
```

## DatasetDict[[datasets.DatasetDict]]

Словарь, в котором ключами являются имена разбиений (например, 'train', 'test'), а значениями — объекты `Dataset`. Он также содержит методы трансформации набора данных, такие как map или filter, для обработки всех разбиений сразу.

#### datasets.DatasetDict[[datasets.DatasetDict]]

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L54)

Словарь (dict со str: datasets.Dataset) с методами трансформации датасетов (map, filter и т. д.)

#### data[[datasets.DatasetDict.data]]

```python
data()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L95)

Таблицы Apache Arrow, лежащие в основе каждого разбиения.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.data
```

#### cache_files[[datasets.DatasetDict.cache_files]]

```python
cache_files()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L110)

Файлы кэша, содержащие таблицы Apache Arrow, лежащие в основе каждого разбиения.

Пример:

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

#### num_columns[[datasets.DatasetDict.num_columns]]

```python
num_columns()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L128)

Количество столбцов в каждом разбиении набора данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.num_columns
{'test': 2, 'train': 2, 'validation': 2}
```

#### num_rows[[datasets.DatasetDict.num_rows]]

```python
num_rows()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L144)

Количество строк в каждом разделе набора данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.num_rows
{'test': 1066, 'train': 8530, 'validation': 1066}
```

#### column_names[[datasets.DatasetDict.column_names]]

```python
column_names()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L160)

Имена столбцов в каждом разбиении набора данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.column_names
{'test': ['text', 'label'],
 'train': ['text', 'label'],
 'validation': ['text', 'label']}
```

#### shape[[datasets.DatasetDict.shape]]

```python
shape()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L178)

Форма каждого разбиения набора данных (количество строк, количество столбцов).

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.shape
{'test': (1066, 2), 'train': (8530, 2), 'validation': (1066, 2)}
```

#### unique[[datasets.DatasetDict.unique]]

```python
unique(column: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L227)

**Параметры:**

column (`str`) : имя столбца (список всех имён столбцов — [column_names](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict.column_names))

**Возвращает:** Dict[`str`, `list`]

Словарь уникальных элементов в указанном столбце.

Возвращает список уникальных элементов в столбце для каждого сплита.

Это реализовано в низкоуровневом бэкенде и, как следствие, работает очень быстро.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.unique("label")
{'test': [1, 0], 'train': [1, 0], 'validation': [1, 0]}
```

#### cleanup_cache_files[[datasets.DatasetDict.cleanup_cache_files]]

```python
cleanup_cache_files()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L251)

**Возвращает:**

`Dict` с количеством удалённых файлов для каждого сплита

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

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.cleanup_cache_files()
{'test': 0, 'train': 0, 'validation': 0}
```

#### map[[datasets.DatasetDict.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, features: typing.Optional[datasets.features.features.Features] = None, disable_nullable: bool = False, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None, try_original_type: typing.Optional[bool] = True, on_mixed_types: typing.Optional[typing.Literal['use_json']] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L838)

**Параметры:**

function (`callable`) : с одной из следующих сигнатур: - `function(example: Dict[str, Any]) -> Dict[str, Any]`, если `batched=False` и `with_indices=False` - `function(example: Dict[str, Any], indices: int) -> Dict[str, Any]`, если `batched=False` и `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]`, если `batched=True` и `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]`, если `batched=True` и `with_indices=True` Для расширенного использования функция также может возвращать `pyarrow.Table`. Если функция асинхронная, `map` выполнит её параллельно. Кроме того, если функция ничего не возвращает (`None`), `map` выполнит её и вернёт датасет без изменений. Если функция не задана, по умолчанию используется тождественная функция: `lambda x: x`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx): ...`.

with_rank (`bool`, по умолчанию `False`) : Передать ранг процесса в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example[, idx], rank): ...`.

with_split (`bool`, по умолчанию `False`) : Передать разбиение процесса в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example[, idx], split): ...`.

input_columns (`[Union[str, list[str]]]`, *необязательный*, по умолчанию `None`) : Столбцы, которые передаются в `function` в качестве позиционных аргументов. Если указано `None`, в качестве одного аргумента передаётся словарь, отображающий все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`.

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched=True`, `batch_size <= 0` или `batch_size == None`, то весь набор данных передается в `function` как одна партия.

drop_last_batch (`bool`, по умолчанию `False`) : следует ли отбрасывать последний батч, если его размер меньше batch_size, вместо того чтобы обрабатывать его функцией.

remove_columns (`[Union[str, list[str]]]`, *необязательный*, по умолчанию `None`) : Удаляет выбранные столбцы во время выполнения отображения. Столбцы удаляются до обновления примеров с помощью вывода `function`, то есть если `function` добавляет столбцы с именами из `remove_columns`, эти столбцы будут сохранены.

keep_in_memory (`bool`, по умолчанию `False`) : Держать датасет в памяти, а не записывать его в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий текущие вычисления из `function`, использовать его вместо повторного вычисления.

cache_file_names (`[Dict[str, str]]`, *необязательный*, по умолчанию `None`) : Укажите имя пути для файла кэша. Он используется для хранения результатов вычислений вместо автоматически сгенерированного имени файла кэша. Необходимо указать один `cache_file_name` для каждого набора данных в словаре наборов данных.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

features (`[datasets.Features]`, *необязательный*, по умолчанию `None`) : Использовать определённые [Features](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features) для хранения файла кэша вместо автоматически сгенерированных.

disable_nullable (`bool`, по умолчанию `False`) : Запретить значения null в таблице.

fn_kwargs (`Dict`, *необязательный*, по умолчанию `None`) : Именованные аргументы, передаваемые в `function`

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов для использования в многопроцессности. - Если `None` или `0`, многопроцессность не используется, и операция выполняется в основном процессе. - Если значение больше `1`, для параллельной обработки данных используются один или несколько рабочих процессов. Примечание: Функция, передаваемая в `map()`, должна быть сериализуемой (picklable), чтобы многопроцессность работала корректно (т. е. предпочтительнее использовать функции, определённые на верхнем уровне модуля, а не внутри другой функции или класса).

desc (`str`, *необязательный*, по умолчанию `None`) : Осмысленное описание, отображаемое рядом с прогресс-баром при отображении примеров.

try_original_type (`Optional[bool]`, по умолчанию `True`) : Пытаться сохранять типы исходных столбцов (например, int32 -> int32). Установите False, если вы хотите всегда выводить новые типы.

on_mixed_types (`Literal["use_json"]`, *необязательный*, по умолчанию `None`) : Если указано "use_json", для полей со смешанными типами используется тип Json(), то есть для неструктурированных полей, содержащих данные без заранее определённой схемы. В этом случае полю со смешанным типом присваивается Json().  Это позволяет, например, загружать списки, содержащие смесь строк/целых чисел/чисел с плавающей точкой, или словари с произвольными типами значений.

Применяет функцию ко всем примерам в таблице (по отдельности или партиями) и обновляет таблицу. Если функция возвращает столбец, который уже существует, он будет перезаписан. Преобразование применяется ко всем наборам данных в словаре наборов данных.

Вы можете указать, должна ли функция обрабатываться батчами или нет, с помощью параметра `batched`:

- Если `False`, функция принимает один пример и должна вернуть один пример. Примером является словарь, например `{"text": "Hello there !"}`.
- If batched is `True` and `batch_size` is 1, then the function takes a batch of 1 example as input and can return a batch with 1 or more examples. A batch is a dictionary, e.g. a batch of 1 example is `{"text": ["Hello there !"]}`.
- Если `True` и `batch_size` равно `n > 1`, функция принимает на вход батч из `n` примеров и может вернуть батч из `n` примеров или произвольного количества примеров. Обратите внимание, что в последнем батче может быть меньше `n` примеров. Батч — это словарь, например, батч из `n` примеров имеет вид `{"text": ["Hello there !"] * n}`.

Если функция асинхронная, то `map` будет выполнять её параллельно, с максимумом в тысячу одновременных вызовов. Рекомендуется использовать `asyncio.Semaphore` в вашей функции, если вы хотите задать максимальное количество операций, которые могут выполняться одновременно.

Пример:

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

# process a batch of examples
>>> ds = ds.map(lambda example: tokenizer(example["text"]), batched=True)
# set number of processors
>>> ds = ds.map(add_prefix, num_proc=4)
```

#### фильтр[[datasets.DatasetDict.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_rank: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None, num_proc: typing.Optional[int] = None, desc: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1010)

**Параметры:**

function (`Callable`) : Вызываемый объект с одной из следующих сигнатур:  - `function(example: Dict[str, Any]) -> bool`, если `batched=False` и `with_indices=False` и `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool`, если `batched=False` и `with_indices=True` и/или `with_rank=True` (один дополнительный аргумент для каждого) - `function(batch: Dict[str, list]) -> list[bool]`, если `batched=True` и `with_indices=False` и `with_rank=False` - `function(batch: Dict[str, list], *extra_args) -> list[bool]`, если `batched=True` и `with_indices=True` и/или `with_rank=True` (один дополнительный аргумент для каждого)  Если функция не указана, по умолчанию используется функция, всегда возвращающая `True`: `lambda x: True`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx[, rank]): ...`.

with_rank (`bool`, по умолчанию `False`) : Передать ранг процесса в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example[, idx], rank): ...`.

input_columns (`[Union[str, list[str]]]`, *необязательный*, по умолчанию `None`) : Столбцы, которые передаются в `function` в качестве позиционных аргументов. Если указано `None`, в качестве одного аргумента передаётся словарь, отображающий все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`.

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched=True`. Если `batch_size <= 0` или `batch_size == None`, то весь набор данных передаётся в `function` как одна партия.

keep_in_memory (`bool`, по умолчанию `False`) : Держать датасет в памяти, а не записывать его в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий текущие вычисления из `function`, использовать его вместо повторного вычисления.

cache_file_names (`[Dict[str, str]]`, *необязательный*, по умолчанию `None`) : Укажите имя пути для файла кэша. Он используется для хранения результатов вычислений вместо автоматически сгенерированного имени файла кэша. Необходимо указать один `cache_file_name` для каждого набора данных в словаре наборов данных.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

fn_kwargs (`Dict`, *необязательный*, по умолчанию `None`) : Именованные аргументы, передаваемые в `function`

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов для использования в многопроцессности. - Если `None` или `0`, многопроцессность не используется, и операция выполняется в основном процессе. - Если значение больше `1`, для параллельной обработки данных используются один или несколько рабочих процессов. Примечание: Функция, передаваемая в `map()`, должна быть сериализуемой (picklable), чтобы многопроцессность работала корректно (т. е. предпочтительнее использовать функции, определённые на верхнем уровне модуля, а не внутри другой функции или класса).

desc (`str`, *необязательный*, по умолчанию `None`) : Осмысленное описание, отображаемое рядом с индикатором прогресса во время фильтрации примеров.

Примените функцию фильтрации ко всем элементам таблицы партиями и обновите таблицу так, чтобы набор данных содержал только примеры, соответствующие функции фильтрации. Преобразование применяется ко всем наборам данных в словаре наборов данных.

Пример:

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

#### sort[[datasets.DatasetDict.sort]]

```python
sort(column_names: typing.Union[str, collections.abc.Sequence[str]], reverse: typing.Union[bool, collections.abc.Sequence[bool]] = False, null_placement: str = 'at_end', keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1175)

**Параметры:**

column_names (`Union[str, Sequence[str]]`) : Имя(я) столбца(ов) для сортировки.

reverse (`Union[bool, Sequence[bool]]`, по умолчанию `False`) : Если `True`, сортировка выполняется по убыванию, а не по возрастанию. Если указано одно значение bool, оно применяется к сортировке всех имён столбцов. В противном случае необходимо предоставить список значений bool той же длины и в том же порядке, что и column_names.

null_placement (`str`, по умолчанию `at_end`) : Размещать значения `None` в начале, если указано `at_start` или `first`, или в конце, если указано `at_end` или `last`

keep_in_memory (`bool`, по умолчанию `False`) : Хранить отсортированные индексы в памяти, а не записывать их в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий отсортированные индексы, используйте его вместо повторного вычисления.

indices_cache_file_names (`[Dict[str, str]]`, *необязательный*, по умолчанию `None`) : Укажите имя пути для файла кэша. Он используется для хранения индексов соответствия вместо автоматически сгенерированного имени файла кэша. Необходимо указать один `cache_file_name` для каждого набора данных в словаре наборов данных.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Более высокое значение приводит к меньшим файлам кэша, более низкое значение потребляет меньше временной памяти.

Создайте новый набор данных, отсортированный по одному или нескольким столбцам.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset('cornell-movie-review-data/rotten_tomatoes')
>>> ds['train']['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
>>> sorted_ds = ds.sort('label')
>>> sorted_ds['train']['label'][:10]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> another_sorted_ds = ds.sort(['label', 'text'], reverse=[True, False])
>>> another_sorted_ds['train']['label'][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
```

#### shuffle[[datasets.DatasetDict.shuffle]]

```python
shuffle(seeds: typing.Union[int, dict[str, typing.Optional[int]], NoneType] = None, seed: typing.Optional[int] = None, generators: typing.Optional[dict[str, numpy.random._generator.Generator]] = None, keep_in_memory: bool = False, load_from_cache_file: typing.Optional[bool] = None, indices_cache_file_names: typing.Optional[dict[str, typing.Optional[str]]] = None, writer_batch_size: typing.Optional[int] = 1000)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1242)

**Параметры:**

seeds (`Dict[str, int]` или `int`, *необязательный*) : Значение seed для инициализации стандартного BitGenerator, если `generator=None`. Если указано `None`, то непредсказуемая энтропия будет получена из ОС. Если передано значение типа `int` или `array_like[ints]`, оно будет передано в SeedSequence для вывода начального состояния BitGenerator. В словаре датасета можно указать по одному `seed` для каждого датасета.

seed (`int`, *optional*) : Значение seed для инициализации стандартного BitGenerator, если `generator=None`. Псевдоним для seeds (будет вызвано `ValueError`, если указаны оба параметра).

generators (`Dict[str, *optional*, np.random.Generator]`) : Случайный генератор Numpy, используемый для вычисления перестановки строк набора данных. Если `generator=None` (по умолчанию), используется `np.random.default_rng` (генератор битов по умолчанию (PCG64) в NumPy). Необходимо указать один `generator` для каждого набора данных в словаре наборов данных.

keep_in_memory (`bool`, по умолчанию `False`) : Держать датасет в памяти, а не записывать его в файл кэша.

load_from_cache_file (`Optional[bool]`, по умолчанию `True`, если кэширование включено) : Если можно определить файл кэша, содержащий текущие вычисления из `function`, использовать его вместо повторного вычисления.

indices_cache_file_names (`Dict[str, str]`, *необязательный*) : Укажите имя пути для файла кэша. Он используется для хранения соответствий индексов вместо автоматически сгенерированного имени файла кэша. Необходимо указать один `cache_file_name` для каждого набора данных в словаре наборов данных.

writer_batch_size (`int`, по умолчанию `1000`) : Количество строк на операцию записи для модуля записи в файл кэша. Это значение представляет собой хороший компромисс между использованием памяти во время обработки и скоростью обработки. Более высокое значение уменьшает количество обращений к данным, а более низкое значение потребляет меньше временной памяти при выполнении `map`.

Создайте новый Dataset, в котором строки перемешаны.

Преобразование применяется ко всем наборам данных в словаре наборов данных.

В настоящее время перемешивание использует генераторы случайных чисел NumPy. Вы можете передать экземпляр NumPy BitGenerator для использования или значение seed для инициализации генератора случайных чисел по умолчанию в NumPy (PCG64).

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds["train"]["label"][:10]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

# set a seed
>>> shuffled_ds = ds.shuffle(seed=42)
>>> shuffled_ds["train"]["label"][:10]
[0, 1, 0, 1, 0, 0, 0, 0, 0, 0]
```

#### set_format[[datasets.DatasetDict.set_format]]

```python
set_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L595)

**Параметры:**

type (`str`, *необязательный*) : Тип вывода, выбранный из `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` означает, что `__getitem__` возвращает объекты Python (по умолчанию).

columns (`list[str]`, *необязательный*) : Столбцы, которые нужно отформатировать в выводе. `None` означает, что `__getitem__` возвращает все столбцы (по умолчанию).

output_all_columns (`bool`, по умолчанию False) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python),

- ****format_kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в функцию преобразования, например `np.array`, `torch.tensor` или `tensorflow.ragged.constant`.

Формат возвращаемого значения `__getitem__` (тип и столбцы). Формат задаётся для каждого набора данных в словаре наборов данных.

Возможно вызвать `map` после вызова `set_format`. Поскольку `map` может добавлять новые столбцы, список отформатированных столбцов обновляется. В этом случае, если вы применяете `map` к набору данных для добавления нового столбца, этот столбец будет отформатирован:

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

Пример:

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

#### reset_format[[datasets.DatasetDict.reset_format]]

```python
reset_format()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L646)

Сбросить формат возвращаемого значения `__getitem__` до объектов Python и всех столбцов. Преобразование применяется ко всем наборам данных в словаре наборов данных.

Аналогично `self.set_format()`

Пример:

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

#### formatted_as[[datasets.DatasetDict.formatted_as]]

```python
formatted_as(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L555)

**Параметры:**

type (`str`, *необязательный*) : Тип вывода, выбранный из `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` означает, что `__getitem__` возвращает объекты Python (по умолчанию).

columns (`list[str]`, *необязательный*) : Столбцы, которые нужно отформатировать в выводе. `None` означает, что `__getitem__` возвращает все столбцы (по умолчанию).

output_all_columns (`bool`, по умолчанию False) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python).

- ****format_kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в функцию преобразования, например `np.array`, `torch.tensor` или `tensorflow.ragged.constant`.

Используется в операторе `with`. Задаёт формат возврата `__getitem__` (тип и столбцы). Преобразование применяется ко всем наборам данных в словаре наборов данных.

#### with_format[[datasets.DatasetDict.with_format]]

```python
with_format(type: typing.Optional[str] = None, columns: typing.Optional[list] = None, output_all_columns: bool = False, **format_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L707)

**Параметры:**

type (`str`, *необязательный*) : Тип вывода, выбранный из `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` означает, что `__getitem__` возвращает объекты Python (по умолчанию).

columns (`list[str]`, *необязательный*) : Столбцы, которые нужно отформатировать в выводе. `None` означает, что `__getitem__` возвращает все столбцы (по умолчанию).

output_all_columns (`bool`, по умолчанию `False`) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python).

- ****format_kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в функцию преобразования, например `np.array`, `torch.tensor` или `tensorflow.ragged.constant`.

Формат возвращаемого значения `__getitem__` (тип и столбцы). Форматирование данных выполняется на лету. Формат `type` (например, "numpy") используется для форматирования батчей при использовании `__getitem__`. Формат устанавливается для каждого набора данных в словаре наборов данных.

Также можно использовать пользовательские преобразования для форматирования с помощью [with_transform()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.with_transform).

В отличие от [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict.set_format), `with_format` возвращает новый объект [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) с новыми объектами [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset).

Пример:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds["train"].format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': None}
>>> ds = ds.with_format("torch")
>>> ds["train"].format
{'columns': ['text', 'label', 'input_ids', 'token_type_ids', 'attention_mask'],
 'format_kwargs': {},
 'output_all_columns': False,
 'type': 'torch'}
>>> ds["train"][0]
{'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'label': tensor(1),
 'input_ids': tensor([  101, 18027, 16310, 16001,  1103,  9321,   178, 11604,  7235,  6617,
        1742,  2165,  2820,  1206,  6588, 22572, 12937,  1811,  2153,  1105,
        1147, 12890, 19587,  6463,  1105, 15026,  1482,   119,   102,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}
```

#### with_transform[[datasets.DatasetDict.with_transform]]

```python
with_transform(transform: typing.Optional[typing.Callable], columns: typing.Optional[list] = None, output_all_columns: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L784)

**Параметры:**

transform (`Callable`, *необязательный*) : Пользовательское преобразование форматирования, заменяющее формат, определённый в [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format). Функция форматирования — это вызываемый объект, который принимает батч (в виде словаря) на вход и возвращает батч. Эта функция применяется непосредственно перед возвратом объектов в `__getitem__`.

columns (`list[str]`, *необязательный*) : Столбцы, которые нужно отформатировать в выводе. Если указано, то входная партия данных для преобразования содержит только эти столбцы.

output_all_columns (`bool`, по умолчанию False) : Сохранять в выводе также и неформатированные столбцы (в виде объектов Python). Если установлено в `True`, остальные неформатированные столбцы сохраняются вместе с результатом преобразования.

Установите формат возврата `__getitem__` с помощью этого преобразования. Преобразование применяется на лету к батчам при вызове `__getitem__`. Преобразование устанавливается для каждого набора данных в словаре наборов данных

Как и [set_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.set_format), это можно сбросить с помощью [reset_format()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.reset_format).

В отличие от `set_transform()`, `with_transform` возвращает новый объект [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) с новыми объектами [Dataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset).

Пример:

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

#### flatten[[datasets.DatasetDict.flatten]]

```python
flatten(max_depth = 16)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L194)

Выравнивание таблицы Apache Arrow для каждого сплита (вложенные признаки выравниваются). Каждый столбец со структурированным типом выравнивается в один столбец на каждое поле структуры. Остальные столбцы остаются без изменений.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("rajpurkar/squad")
>>> ds["train"].features
{'id': Value('string'),
 'title': Value('string'),
 'context': Value('string'),
 'question': Value('string'),
 'answers.text': List(Value('string')),
 'answers.answer_start': List(Value('int32'))}
>>> ds.flatten()
DatasetDict({
    train: Dataset({
        features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'],
        num_rows: 87599
    })
    validation: Dataset({
        features: ['id', 'title', 'context', 'question', 'answers.text', 'answers.answer_start'],
        num_rows: 10570
    })
})
```

#### cast[[datasets.DatasetDict.cast]]

```python
cast(features: Features)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L275)

**Параметры:**

features ([Возможности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features)) : Новые возможности для приведения набора данных. Имена и порядок полей в features должны совпадать с текущими именами столбцов. Тип данных также должен допускать преобразование из одного типа в другой. Для нетривиальных преобразований, например `string` <-> `ClassLabel`, следует использовать [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict.map) для обновления набора данных.

Приведите набор данных к новому набору признаков. Преобразование применяется ко всем наборам данных в словаре наборов данных.

Пример:

```py
>>> from datasets import load_dataset, ClassLabel, Value
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds["train"].features.copy()
>>> new_features['label'] = ClassLabel(names=['bad', 'good'])
>>> new_features['text'] = Value('large_string')
>>> ds = ds.cast(new_features)
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### cast_column[[datasets.DatasetDict.cast_column]]

```python
cast_column(column: str, feature)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L307)

**Параметры:**

column (`str`) : Имя столбца.

feature (`Feature`) : Целевая переменная.

**Возвращает:**

[DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Преобразование столбца в признак для декодирования.

Пример:

```py
>>> from datasets import load_dataset, ClassLabel
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good']))
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('string')}
```

#### remove_columns[[datasets.DatasetDict.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L336)

**Параметры:**

column_names (`Union[str, list[str]]`) : Имя столбца (столбцов) для удаления.

**Возвращает:** [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Копия объекта набора данных без удаляемых столбцов.

Удалите одну или несколько столбцов из каждого разбиения набора данных, а также связанные с этими столбцами признаки.

Преобразование применяется ко всем частям словаря набора данных.

Также можно удалить столбец с помощью [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict.map) и параметра `remove_columns`, но описанный выше метод не копирует данные оставшихся столбцов, поэтому работает быстрее.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds = ds.remove_columns("label")
DatasetDict({
    train: Dataset({
        features: ['text'],
        num_rows: 8530
    })
    validation: Dataset({
        features: ['text'],
        num_rows: 1066
    })
    test: Dataset({
        features: ['text'],
        num_rows: 1066
    })
})
```

#### rename_column[[datasets.DatasetDict.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L378)

**Параметры:**

original_column_name (`str`) : Имя переименовываемой колонки.

new_column_name (`str`) : Новое имя столбца.

Переименование столбца в наборе данных и перемещение признаков, связанных с исходным столбцом, под новое имя столбца. Преобразование применяется ко всем наборам данных в словаре наборов данных.

Также можно переименовать столбец с помощью [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict.map) и `remove_columns`, но данный метод:
- отвечает за перемещение исходных признаков под новое имя столбца.
- не копирует данные в новый набор данных и поэтому работает значительно быстрее.

Пример:

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

#### rename_columns[[datasets.DatasetDict.rename_columns]]

```python
rename_columns(column_mapping: dict)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L426)

**Параметры:**

column_mapping (`Dict[str, str]`) : Соответствие столбцов, которые нужно переименовать, и их новых имён.

**Возвращает:** [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Копия набора данных с переименованными столбцами.

Переименовать несколько столбцов в наборе данных и переместить признаки, связанные с исходными столбцами, под новые имена столбцов. Преобразование применяется ко всем наборам данных в словаре наборов данных.

Пример:

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

#### select_columns[[datasets.DatasetDict.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L464)

**Параметры:**

column_names (`Union[str, list[str]]`) : Имя столбца (столбцов), который нужно сохранить.

Выберите одну или несколько колонок из каждого разбиения набора данных, а также связанные с ними признаки.

Преобразование применяется ко всем частям словаря набора данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds.select_columns("text")
DatasetDict({
    train: Dataset({
        features: ['text'],
        num_rows: 8530
    })
    validation: Dataset({
        features: ['text'],
        num_rows: 1066
    })
    test: Dataset({
        features: ['text'],
        num_rows: 1066
    })
})
```

#### with_column_metadata[[datasets.DatasetDict.with_column_metadata]]

```python
with_column_metadata(column_metadata: dict)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L500)

**Параметры:**

column_metadata (`dict[str, dict[str, str]]`) : Соответствие между именем столбца и его новыми метаданными, словарем строк, аналогичным метаданным полей Arrow. Заменяет текущие метаданные этих столбцов; пустой словарь удаляет их.

Возвращает словарь датасета с указанными метаданными для некоторых столбцов каждого сплита. Подробности см. в [with_column_metadata()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.with_column_metadata).

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes")
>>> ds = ds.with_column_metadata({"text": {"language": "en"}})
>>> ds["train"].info.column_metadata
{'text': {'language': 'en'}}
```

#### class_encode_column[[datasets.DatasetDict.class_encode_column]]

```python
class_encode_column(column: str, include_nulls: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L523)

**Параметры:**

column (`str`) : Имя столбца, который нужно преобразовать.

include_nulls (`bool`, по умолчанию `False`) : Включать ли значения null в классы меток. Если `True`, значения null будут закодированы как метка класса `"None"`.

Преобразует указанную колонку в [ClassLabel](/docs/datasets/main/ru/package_reference/main_classes#datasets.ClassLabel) и обновляет таблицы.

Пример:

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

#### push_to_hub[[datasets.DatasetDict.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None, append: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1647)

**Параметры:**

repo_id (`str`) : Идентификатор репозитория, в который выполняется отправка, в формате `<user>/<dataset_name>` или `<org>/<dataset_name>`. Также принимается `<dataset_name>`, в этом случае используется пространство имен текущего пользователя по умолчанию. Также может указываться путь внутри бакета, например `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`) : Имя конфигурации набора данных. По умолчанию — "default".

set_default (`bool`, *необязательный*) : Указывает, следует ли устанавливать эту конфигурацию в качестве конфигурации по умолчанию. В противном случае конфигурацией по умолчанию является та, что называется "default".

data_dir (`str`, *необязательный*) : Имя каталога, который будет содержать загруженные файлы данных. По умолчанию используется `config_name`, если он отличается от "default", иначе "data".

commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию — `"Upload dataset"`.

commit_description (`str`, *необязательный*) : Описание коммита, который будет создан. Кроме того, описание PR, если PR будет создан (`create_pr` равно True).

private (`bool`, *optional*) : Указывает, нужно ли сделать репозиторий приватным. Если `None` (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.

token (`str`, *необязательный*) : Необязательный токен аутентификации для Hugging Face Hub. Если токен не передан, по умолчанию будет использован токен, сохранённый локально при входе с помощью `hf auth login`. Если токен не передан и пользователь не вошёл в систему, будет выброшена ошибка.

revision (`str`, *необязательный*) : Ветка, в которую будут отправлены загруженные файлы. По умолчанию используется ветка `"main"`.

create_pr (`bool`, *необязательный*, по умолчанию `False`) : Создавать ли PR с загруженными файлами или коммитить изменения напрямую.

max_shard_size (`int` или `str`, *необязательный*, по умолчанию `"500MB"`) : Максимальный размер фрагментов набора данных, загружаемых в хаб. Если значение указано в виде строки, оно должно состоять из цифр, за которыми следует единица измерения (например, `"500MB"` или `"1GB"`).

num_shards (`Dict[str, int]`, *необязательный*) : Количество шардов для записи. По умолчанию количество шардов зависит от `max_shard_size`. Используйте словарь, чтобы задать разное значение num_shards для каждого сплита.

embed_external_files (`bool`, по умолчанию `True`) : Встраивать ли байты файлов в шарды. В частности, перед отправкой для полей следующих типов: - [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) и [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image) — удаляется информация о локальном пути, а содержимое файла встраивается в файлы Parquet.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов при подготовке и загрузке набора данных. Это полезно, если набор данных состоит из множества образцов или медиафайлов для встраивания. Использует контекст "spawn" для работы с hf_xet, rust-клиентом для быстрой загрузки на HF. Многопроцессность по умолчанию отключена.

append (`bool`, по умолчанию `False`) : Добавляет строки к существующим разбивкам, сохраняя их признаки и строки. Скачивается и расширяется только последний Parquet-шард в порядке отображения карточки, среди всех указанных каталогов. Если его размер превысит `max_shard_size`, он сохраняется, а новые строки записываются в новые шарды. С помощью `num_shards` указывается общее количество шардов в разбивке после добавления; оно не может быть меньше существующего количества. Новые или переименованные шарды используют `data_dir`. Другие разбивки и конфигурации сохраняются. Поддерживается только для репозиториев датасетов.

**Возвращает:**

huggingface_hub.CommitInfo

Выгружает [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) на хаб в формате Parquet. [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) выгружается с помощью HTTP-запросов, поэтому не требуется установка git или git-lfs.

Каждый раздел набора данных будет загружен независимо. Загруженный набор данных сохранит исходные имена разделов.

Полученные файлы Parquet по умолчанию являются самодостаточными: если ваш набор данных содержит данные [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image) или [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio), файлы Parquet будут хранить байты ваших изображений или аудиофайлов. Вы можете отключить это, установив `embed_external_files` в False.

Пример:

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

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

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

#### save_to_disk[[datasets.DatasetDict.save_to_disk]]

```python
save_to_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, num_proc: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1325)

**Параметры:**

dataset_dict_path (`path-like`) : Path (например, `dataset/train`) или удалённый URI (например, `s3://my-bucket/dataset/train`) каталога словаря датасета, в который будет сохранён словарь датасета.

max_shard_size (`int` или `str`, *необязательный*, по умолчанию `"500MB"`) : Максимальный размер фрагментов набора данных, сохраняемых в файловую систему. Если значение указано в виде строки, оно должно состоять из цифр, за которыми следует единица измерения (например, `"50MB"`).

num_shards (`Dict[str, int]`, *необязательный*) : Количество шардов для записи. По умолчанию количество шардов зависит от `max_shard_size` и `num_proc`. Необходимо указать количество шардов для каждого набора данных в словаре наборов данных. Используйте словарь, чтобы задать разное значение num_shards для каждого сплита.

num_proc (`int`, *необязательный*, по умолчанию `None`) : Количество процессов при загрузке и генерации набора данных локально. Многопоточность отключена по умолчанию.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

Сохраняет словарь датасета в файловую систему с помощью `fsspec.spec.AbstractFileSystem`.

Для данных [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) и [Video](/docs/datasets/main/ru/package_reference/main_classes#datasets.Video):

Все данные Image(), Audio() и Video() хранятся в файлах arrow. Если вы хотите хранить пути или URL, используйте тип Value("string").

Пример:

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

#### load_from_disk[[datasets.DatasetDict.load_from_disk]]

```python
load_from_disk(dataset_dict_path: typing.Union[str, bytes, os.PathLike], keep_in_memory: typing.Optional[bool] = None, storage_options: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1399)

**Параметры:**

dataset_dict_path (`path-like`) : Path (например, `"dataset/train"`) или удалённый URI (например, `"s3//my-bucket/dataset/train"`) каталога словаря датасета, из которого будет загружен словарь датасета.

keep_in_memory (`bool`, по умолчанию `None`) : Копировать ли датасет в оперативную память. Если `None`, датасет не будет скопирован в оперативную память, если только это явно не включено путём установки `datasets.config.IN_MEMORY_MAX_SIZE` в ненулевое значение. Подробнее см. в разделе [улучшение производительности](../cache#improve-performance).

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

**Возвращает:**

[DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Загрузите набор данных, ранее сохранённый с помощью `save_to_disk` из файловой системы с использованием `fsspec.spec.AbstractFileSystem`.

Пример:

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

#### from_csv[[datasets.DatasetDict.from_csv]]

```python
from_csv(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1459)

**Параметры:**

path_or_paths (`dict` из path-like) : Путь (или пути) к файлу (файлам) CSV.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (str, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `pandas.read_csv`.

**Возвращает:**

[DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Создание [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) из файла(ов) CSV.

Пример:

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

#### from_json[[datasets.DatasetDict.from_json]]

```python
from_json(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1502)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (пути) к файлу (файлам) JSON Lines.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (str, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `JsonConfig`.

**Возвращает:**

[DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Создание [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) из файла(ов) JSON Lines.

Пример:

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

#### from_parquet[[datasets.DatasetDict.from_parquet]]

```python
from_parquet(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1545)

**Параметры:**

path_or_paths (`dict` из path-like) : Путь (или пути) к файлу (файлам) CSV.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

columns (`list[str]`, *необязательный*) : Если не `None`, из файла будут читаться только эти столбцы. Имя столбца может быть префиксом вложенного поля, например, 'a' выберет 'a.b', 'a.c' и 'a.d.e'.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `ParquetConfig`.

**Возвращает:**

[DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Создание [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) из файла(ов) Parquet.

Пример:

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

#### from_text[[datasets.DatasetDict.from_text]]

```python
from_text(path_or_paths: dict, features: typing.Optional[datasets.features.features.Features] = None, cache_dir: str = None, keep_in_memory: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1594)

**Параметры:**

path_or_paths (`dict` с путями) : Путь (или пути) к текстовому файлу (или файлам).

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

cache_dir (`str`, *необязательный*, по умолчанию `"~/.cache/huggingface/datasets"`) : Каталог для кэширования данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `TextConfig`.

**Возвращает:**

[DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict)

Создание [DatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetDict) из текстового файла или файлов.

Пример:

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

## IterableDataset[[datasets.IterableDataset]]

Базовый класс [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset) реализует итерируемый Dataset, основанный на генераторах Python.

#### datasets.IterableDataset[[datasets.IterableDataset]]

```python
datasets.IterableDataset(ex_iterable: _BaseExamplesIterable, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, formatting: typing.Optional[datasets.iterable_dataset.FormattingConfig] = None, distributed: typing.Optional[datasets.iterable_dataset.DistributedConfig] = None, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2709)

Набор данных, основанный на итерируемом объекте.

#### from_file[[datasets.IterableDataset.from_file]]

```python
from_file(filename: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3216)

**Параметры:**

filename (`str`) : Имя файла набора данных.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Создайте экземпляр IterableDataset из таблицы Arrow по имени файла.

#### from_pandas[[datasets.IterableDataset.from_pandas]]

```python
from_pandas(df: DataFrame, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, preserve_index: typing.Optional[bool] = None, num_shards: typing.Optional[int] = 1)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3232)

**Параметры:**

df (`pandas.DataFrame`) : DataFrame, содержащий набор данных.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

info (`DatasetInfo`, *необязательный*) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, *необязательный*) : Имя сплита набора данных.

preserve_index (`bool`, *необязательный*) : Указывает, следует ли сохранять индекс как дополнительный столбец в результирующем Dataset. Значение по умолчанию `None` сохраняет индекс как столбец, за исключением `RangeIndex`, который хранится только в метаданных. Используйте `preserve_index=True`, чтобы принудительно сохранить его как столбец.

num_shards (`int`, по умолчанию `1`) : Количество шардов, определяемых при создании итерируемого набора данных. Это особенно полезно для больших наборов данных, чтобы обеспечить корректное перемешивание, а также для быстрого параллельного чтения с помощью PyTorch DataLoader или в распределённых средах.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Преобразуйте `pandas.DataFrame` в `pyarrow.Table`, чтобы создать [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset).

Типы столбцов в результирующей таблице Arrow выводятся из dtypes `pandas.Series` в DataFrame. Для Series, не являющихся объектами, NumPy dtype преобразуется в соответствующий ему тип Arrow. В случае `object` необходимо определить тип данных, анализируя Python-объекты в этой Series.

Обратите внимание, что Series с типом данных `object` не содержат достаточной информации для однозначного определения осмысленного типа Arrow. Если тип не удаётся вывести, например, если длина DataFrame равна 0 или Series содержит только объекты `None/nan`, тип устанавливается в `null`. Этого поведения можно избежать, явно создав features и передав их в эту функцию.

Important: a dataset created with from_pandas() lives in memory. This may change in the future, but in the meantime if you want to reduce memory usage you should write it on disk and reload using e.g. to_parquet / from_parquet.

Пример:

```py
>>> ds = IterableDataset.from_pandas(df)
```

#### from_dict[[datasets.IterableDataset.from_dict]]

```python
from_dict(mapping: dict, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3344)

**Параметры:**

mapping (`Mapping`) : отображение строк в массивы или списки Python.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

info (`DatasetInfo`, *необязательный*) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, *необязательный*) : Имя сплита набора данных.

num_shards (`int`, по умолчанию `1`) : Количество шардов, определяемых при создании итерируемого набора данных. Это особенно полезно для больших наборов данных, чтобы обеспечить корректное перемешивание, а также для быстрого параллельного чтения с помощью PyTorch DataLoader или в распределённых средах.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Преобразуйте `dict` в `pyarrow.Table`, чтобы создать [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset).

Important: a dataset created with from_dict() lives in memory. This may change in the future, but in the meantime if you want to reduce memory usage you should write it back on disk and reload using e.g. to_parquet / from_parquet.

#### from_list[[datasets.IterableDataset.from_list]]

```python
from_list(mapping: list, features: typing.Optional[datasets.features.features.Features] = None, info: typing.Optional[datasets.info.DatasetInfo] = None, split: typing.Optional[datasets.splits.NamedSplit] = None, num_shards: typing.Optional[int] = 1)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3381)

**Параметры:**

mapping (`List[dict]`) : список отображений строк в значения строк.

features (`Features`, необязательно) : Функции набора данных.

info (`DatasetInfo`, optional) : Информация о наборе данных, например, описание, цитирование и т. д.

split (`NamedSplit`, optional) : Имя сплита набора данных.

num_shards (`int`, по умолчанию `1`) : Количество шардов, определяемых при создании итерируемого набора данных. Это особенно полезно для больших наборов данных, чтобы обеспечить корректное перемешивание, а также для быстрого параллельного чтения с помощью PyTorch DataLoader или в распределённых средах.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Преобразуйте список словарей в `pyarrow.Table`, чтобы создать [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)`.

Обратите внимание, что ключи первого элемента будут использоваться для определения столбцов набора данных, независимо от того, что передано в features.

Important: a dataset created with from_list() lives in memory. This may change in the future, but in the meantime if you want to reduce memory usage you should write it back on disk and reload using e.g. from_parquet / to_parquet.

#### from_generator[[datasets.IterableDataset.from_generator]]

```python
from_generator(generator: typing.Callable, features: typing.Optional[datasets.features.features.Features] = None, gen_kwargs: typing.Optional[dict] = None, split: NamedSplit = NamedSplit('train'))
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3118)

**Параметры:**

generator (`Callable`) : функция-генератор, которая `yields` примеры.

features (`Features`, *необязательный*) : Функции набора данных.

gen_kwargs(`dict`, *optional*) : Аргументы с ключами, передаваемые в вызываемый объект `generator`. Вы можете определить итерируемый датасет с шардами, передав список шардов в `gen_kwargs`. Это позволяет улучшить перемешивание и используется при итерации по датасету с несколькими воркерами.

split ([NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), по умолчанию `Split.TRAIN`) : Имя сплита, которое будет присвоено набору данных.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Создание набора данных Iterable из генератора.

Пример:

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

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

#### remove_columns[[datasets.IterableDataset.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4382)

**Параметры:**

column_names (`Union[str, List[str]]`) : Имя столбца (столбцов) для удаления.

**Возвращает:** `IterableDataset`

Копия объекта набора данных без удаляемых столбцов.

Удаляет одну или несколько колонок в наборе данных, а также связанные с ними признаки. Удаление выполняется на лету для примеров при итерации по набору данных.

Пример:

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

#### select_columns[[datasets.IterableDataset.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4417)

**Параметры:**

column_names (`Union[str, List[str]]`) : Имя столбца (столбцов) для выбора.

**Возвращает:** `IterableDataset`

Копия объекта набора данных с выбранными столбцами.

Выберите одну или несколько колонок в наборе данных, а также связанные с ними признаки. Выбор выполняется на лету для примеров при итерации по набору данных.

Пример:

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

#### cast_column[[datasets.IterableDataset.cast_column]]

```python
cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4467)

**Параметры:**

column (`str`) : Имя столбца.

feature (`Feature`) : Целевая переменная.

**Возвращает:** `IterableDataset`

Преобразование столбца в признак для декодирования.

Пример:

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

#### cast[[datasets.IterableDataset.cast]]

```python
cast(features: Features)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4513)

**Параметры:**

features ([Возможности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features)) : Новые возможности для приведения набора данных. Имена полей в возможностях должны совпадать с текущими именами столбцов. Тип данных также должен допускать преобразование из одного типа в другой. Для нетривиальных преобразований, например `string` <-> `ClassLabel`, следует использовать [map()](/docs/datasets/main/ru/package_reference/main_classes#datasets.Dataset.map) для обновления набора данных.

**Возвращает:** `IterableDataset`

Копия набора данных с преобразованными признаками.

Преобразовать набор данных в новый набор признаков.

Пример:

```py
>>> from datasets import load_dataset, ClassLabel, Value
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> ds.features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds.features.copy()
>>> new_features["label"] = ClassLabel(names=["bad", "good"])
>>> new_features["text"] = Value("large_string")
>>> ds = ds.cast(new_features)
>>> ds.features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### decode[[datasets.IterableDataset.decode]]

```python
decode(enable: bool = True, num_threads: typing.Optional[int] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4559)

**Параметры:**

enable (`bool`, по умолчанию `True`) : Включает или отключает декодирование признаков.

num_threads (`int`, *необязательный*, по умолчанию `None`) : Включает многопоточность для декодирования признаков. Обратите внимание, что [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset) по умолчанию уже использует несколько потоков при потоковой передаче набора данных с HF, если в нём есть декодируемые признаки. По умолчанию `num_threads` устанавливается в 32, если хотя бы один признак требует декодирования, и в 0 в противном случае.

**Возвращает:** `IterableDataset`

Копия набора данных с преобразованными признаками.

Включить или отключить декодирование признаков датасета для аудио, изображений и видео.

Если включено (по умолчанию), типы медиа декодируются:

* audio -> словарь с ключами "array", "sampling_rate" и "path"
* image -> PIL.Image
* video -> torchcodec.decoders.VideoDecoder

Многопоточность можно включить с помощью `num_threads`: в этом случае каждый медиафайл читается и декодируется в отдельном потоке, что позволяет накладывать сетевые запросы для последовательных примеров друг на друга. Это особенно полезно для ускорения потоковой передачи удалённых данных, и [load_dataset()](/docs/datasets/main/ru/package_reference/loading_methods#datasets.load_dataset) по умолчанию включает многопоточность при потоковой передаче удалённого набора данных с декодируемыми признаками (см. `HF_DATASETS_DECODE_NUM_THREADS`). Наборы данных, читаемые с локального диска, передаются потоком с `num_threads=0`, поскольку для локальных данных на быстрых дисках многопоточность может работать медленнее, чем декодирование в основном потоке. Так как примеры декодируются заранее, каждый активный поток может удерживать один пример в памяти: уменьшите `num_threads`, чтобы снизить потребление памяти.

Отключение декодирования полезно, если вы хотите работать с путями или байтами медиафайлов, не декодируя их содержимое. Чтобы отключить декодирование, можно использовать `.decode(False)`, что эквивалентно вызову `.cast()` или `.cast_column()` со всеми типами Audio, Image и Video, установленными в `decode=False`.

Примеры:

Отключить декодирование:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True)
>>> next(iter(ds))
{'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=2048x1024>,
'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.'}
>>> ds = ds.decode(False)
>>> ds.features
{'image': Image(mode=None, decode=False, id=None),
'text': Value('string')}
>>> next(iter(ds))
{
  'image': {
    'path': 'hf://datasets/sshh12/planet-textures@69dc4cef7a5c4b2cfe387727ec8ea73d4bff7302/train/textures/0000.png',
    'bytes': None
  },
  'text': 'A distant celestial object with an icy crust, displaying a light blue shade, covered with round pits and rugged terrains.'
}
```

Ускорьте потоковую передачу с помощью многопоточности:

```py
>>> import os
>>> from datasets import load_dataset
>>> from tqdm import tqdm
>>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True)
>>> # already threaded by default with 32 threads, but more threads can help going even faster
>>> ds = ds.decode(num_threads=64)
>>> for _ in tqdm(ds):  # 2 times faster !
...     ...
```

#### __iter__[[datasets.IterableDataset.__iter__]]

```python
__iter__()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3063)

#### iter[[datasets.IterableDataset.iter]]

```python
iter(batch_size: int, drop_last_batch: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3084)

**Параметры:**

batch_size (`int`) : размер каждой порции, которую нужно выдавать.

drop_last_batch (`bool`, по умолчанию *False*) : следует ли отбрасывать последний батч, если его размер меньше batch_size

Перебирайте батчи размера *batch_size*.

#### map[[datasets.IterableDataset.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, features: typing.Optional[datasets.features.features.Features] = None, fn_kwargs: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3704)

**Параметры:**

function (`Callable`, *необязательный*, по умолчанию `None`) : Функция, применяемая на лету к примерам при итерации по набору данных. Она должна иметь одну из следующих сигнатур:  - `function(example: Dict[str, Any]) -> Dict[str, Any]`, если `batched=False` и `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]`, если `batched=False` и `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]`, если `batched=True` и `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]`, если `batched=True` и `with_indices=True`  Для расширенного использования функция также может возвращать `pyarrow.Table`. Если функция асинхронная, `map` выполнит её параллельно. Кроме того, если функция ничего не возвращает (`None`), `map` выполнит её и вернёт набор данных без изменений. Если функция не задана, используется функция тождественного отображения: `lambda x: x`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx[, rank]): ...`.

input_columns (`Optional[Union[str, List[str]]]`, по умолчанию `None`) : столбцы, которые передаются в `function` как позиционные аргументы. Если `None`, в качестве одного аргумента передаётся словарь, отображающий все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`.

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched=True`. Если `batch_size <= 0` или `batch_size == None`, то весь набор данных передается в `function` как одна партия.

drop_last_batch (`bool`, по умолчанию `False`) : следует ли отбрасывать последний батч, если его размер меньше batch_size, вместо того чтобы обрабатывать его функцией.

remove_columns (`[List[str]]`, *необязательный*, по умолчанию `None`) : Удаляет выбранные столбцы во время выполнения отображения. Столбцы удаляются до обновления примеров с помощью вывода `function`, то есть если `function` добавляет столбцы с именами из `remove_columns`, эти столбцы будут сохранены.

features (`[Features]`, *необязательный*, по умолчанию `None`) : Типы признаков результирующего набора данных.

fn_kwargs (`Dict`, *необязательный*, по умолчанию `None`) : Именованные аргументы, передаваемые в `function`.

Применяет функцию ко всем примерам в итерируемом наборе данных (по отдельности или партиями) и обновляет их. Если функция возвращает столбец, который уже существует, он будет перезаписан. Функция применяется на лету к примерам при итерации по набору данных.

Вы можете указать, должна ли функция обрабатываться батчами или нет, с помощью параметра `batched`:

- Если `False`, функция принимает один пример и должна вернуть один пример. Примером является словарь, например `{"text": "Hello there !"}`.
- If batched is `True` and `batch_size` is 1, then the function takes a batch of 1 example as input and can return a batch with 1 or more examples. A batch is a dictionary, e.g. a batch of 1 example is {"text": ["Hello there !"]}.
- Если `True` и `batch_size` равно `n` > 1, функция принимает на вход батч из `n` примеров и может вернуть батч из `n` примеров или произвольного количества примеров. Обратите внимание, что в последнем батче может быть меньше `n` примеров. Батч — это словарь, например, батч из `n` примеров имеет вид `{"text": ["Hello there !"] * n}`.

Если функция асинхронная, то `map` будет выполнять её параллельно, с максимумом в тысячу одновременных вызовов. Рекомендуется использовать `asyncio.Semaphore` в вашей функции, если вы хотите задать максимальное количество операций, которые могут выполняться одновременно.

Пример:

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

#### rename_column[[datasets.IterableDataset.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4319)

**Параметры:**

original_column_name (`str`) : Имя переименовываемой колонки.

new_column_name (`str`) : Новое имя столбца.

**Возвращает:** `IterableDataset`

Копия набора данных с переименованной колонкой.

Переименуйте столбец в наборе данных и переместите признаки, связанные с исходным столбцом, под новое имя столбца.

Пример:

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

#### фильтр[[datasets.IterableDataset.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3886)

**Параметры:**

function (`Callable`) : Вызываемый объект с одной из следующих сигнатур:  - `function(example: Dict[str, Any]) -> bool`, если `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool`, если `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]`, если `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]`, если `with_indices=True, batched=True`  Если функция асинхронная, `filter` выполнит её параллельно. Если функция не указана, по умолчанию используется функция, всегда возвращающая True: `lambda x: True`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx): ...`.

input_columns (`str` или `List[str]`, *необязательный*) : Столбцы, которые передаются в `function` как позиционные аргументы. Если `None`, в качестве одного аргумента передаётся словарь, отображающий все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`.

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched=True`.

fn_kwargs (`Dict`, *необязательный*, по умолчанию `None`) : Именованные аргументы, передаваемые в `function`.

Примените функцию фильтрации ко всем элементам, чтобы в наборе данных оставались только примеры, удовлетворяющие условию фильтрации. Фильтрация выполняется на лету при итерации по набору данных.

Если функция асинхронная, то `filter` будет выполнять её параллельно, с максимумом в тысячу одновременных вызовов (настраивается). Рекомендуется использовать `asyncio.Semaphore` в вашей функции, если вы хотите задать максимальное количество операций, которые могут выполняться одновременно.

Пример:

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

#### shuffle[[datasets.IterableDataset.shuffle]]

```python
shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3989)

**Параметры:**

seed (`int`, *необязательный*, по умолчанию `None`) : Случайное зерно, которое будет использоваться для перемешивания набора данных. Оно применяется для выборки из буфера перемешивания, а также для перемешивания фрагментов данных.

generator (`numpy.random.Generator`, *optional*) : Генератор случайных чисел Numpy, используемый для вычисления перестановки строк набора данных. Если `generator=None` (по умолчанию), используется `np.random.default_rng` (генератор битов по умолчанию (PCG64) в NumPy).

buffer_size (`int`, по умолчанию `1000`) : Размер буфера.

max_buffer_input_shards (`int`, по умолчанию `10`) : Максимальное количество шардов, используемых для заполнения буфера за один раз.

Случайным образом перемешивает элементы этого набора данных.

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

Например, если ваш набор данных содержит 10 000 элементов, но `buffer_size` установлен в 1000, то `shuffle` сначала выберет случайный элемент только из первых 1000 элементов в буфере. После выбора элемента его место в буфере заменяется следующим (т. е. 1001-м) элементом, что поддерживает буфер из 1000 элементов.

Если датасет состоит из нескольких шардов, буфер заполняется с использованием не более `max_buffer_input_shards` шардов за раз, при этом также перемешивается порядок шардов. Это значительно повышает качество перемешивания. Входные шарды чередуются внутри каждого узла и воркера, сохраняя количество шардов, доступных для параллельной загрузки данных.

Однако, если порядок был зафиксирован с помощью [skip()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.skip) или [take()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.take), то порядок шардов сохраняется без изменений, и для заполнения буфера используется только один шард за раз.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train", streaming=True)
>>> list(ds.take(3))
[{'text': 'the rock is destined to be the 21st century's new " conan " and that he's going to make a splash even greater than arnold schwarzenegger , jean-claud van damme or steven segal .',
 'label': 1},
 {'text': 'the gorgeously elaborate continuation of " the lord of the rings " trilogy is so huge that a column of words cannot adequately describe co-writer/director peter jackson's expanded vision of j . r . r . tolkien's middle-earth .',
 'label': 1},
 {'text': 'effective but too-tepid biopic', 'label': 1}]
>>> shuffled_ds = ds.shuffle(seed=42)
>>> list(shuffled_ds.take(3))
[{'text': "a sports movie with action that's exciting on the field and a story you care about off it .",
 'label': 1},
 {'text': 'at its best , the good girl is a refreshingly adult take on adultery . . .',
 'label': 1},
 {'text': "sam jones became a very lucky filmmaker the day wilco got dropped from their record label , proving that one man's ruin may be another's fortune .",
 'label': 1}]
>>> resharded_ds = ds.reshard()  # useful to shard Parquet datasets by row group instead of by file, improving shuffling quality on dataset with one or few files.
>>> shuffled_resharded_ds = resharded_ds.shuffle(seed=42)
>>> list(shuffled_resharded_ds.take(3))
[{'text': 'this mistaken-identity picture is so film-culture referential that the final product is a ghost .',
 'label': 0},
 {'text': 'woody allen used to ridicule movies like hollywood ending . now he makes them .',
 'label': 0},
 {'text': "not only is undercover brother as funny , if not more so , than both austin powers films , but it's also one of the smarter , savvier spoofs to come along in some time .",
 'label': 1}]
```

#### batch[[datasets.IterableDataset.batch]]

```python
batch(batch_size: typing.Optional[int] = None, by_column: typing.Union[str, list[str], NoneType] = None, drop_last_batch: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4696)

**Параметры:**

batch_size (`int`, optional) : Количество образцов в каждой партии.

by_column (`Union[str, list[str]`, optional) : Столбец, используемый для объединения примеров в батчи. Последовательные примеры с одинаковым значением в этом столбце группируются в один и тот же батч. Также это может быть список столбцов, если вы хотите формировать батчи по нескольким столбцам. При формировании батчей по столбцу параметр batch_size используется только для контроля размера батчей, которые объединяются или нарезаются во время накопления.

drop_last_batch (`bool`, по умолчанию `False`) : Нужно ли отбрасывать последний неполный батч.

Группируйте образцы из набора данных в батчи.

Пример:

Фиксированный размер батча:

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

Пакеты последовательных выборок с одинаковым значением для my_column:

```py
>>> ds = load_dataset("some_dataset", streaming=True, split="train")
>>> batched_ds = ds.batch(by_column="my_column")
```

#### пропустить[[datasets.IterableDataset.skip]]

```python
skip(n: int)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4089)

**Параметры:**

n (`int`) : Количество элементов, которые нужно пропустить.

Создайте новый [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset), который пропускает первые `n` элементов.

Пример:

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

#### take[[datasets.IterableDataset.take]]

```python
take(n: int)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4175)

**Параметры:**

n (`int`) : Количество элементов для извлечения.

Создайте новый [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset) только с первыми `n` элементами.

Пример:

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

#### shard[[datasets.IterableDataset.shard]]

```python
shard(num_shards: int, index: int, contiguous: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4210)

**Параметры:**

num_shards (`int`) : Количество фрагментов, на которые следует разделить набор данных.

index (`int`) : Какой шунт выбрать и вернуть.

contiguous : (`bool`, по умолчанию `True`): следует ли выбирать непрерывные блоки индексов для шардов.

Возвращает `index`-й фрагмент из набора данных, разделённого на `num_shards` частей.

Это детерминированное разбиение на части. `dataset.shard(n, i)` делит набор данных на непрерывные фрагменты, поэтому после обработки их легко снова объединить. Если `dataset.num_shards % n == l`, то первые `l` набора данных содержат по `(dataset.num_shards // n) + 1` фрагменту, а остальные — по `(dataset.num_shards // n)` фрагментов. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` возвращает набор данных с тем же порядком элементов, что и в исходном. В частности, `dataset.shard(dataset.num_shards, i)` возвращает набор данных с одним фрагментом.

Примечание: n должно быть меньше или равно количеству шардов в наборе данных `dataset.num_shards`.

С другой стороны, `dataset.shard(n, i, contiguous=False)` содержит все шарды набора данных, у которых индекс по модулю `n = i`.

Убедитесь, что операция разделения на шарды выполняется до применения любого оператора, использующего случайность (например, `shuffle`). Лучше всего использовать оператор разделения на шарды на раннем этапе конвейера обработки данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True)
>>> ds
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 4
})
>>> ds.shard(num_shards=2, index=0)
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 2
})
```

#### reshard[[datasets.IterableDataset.reshard]]

```python
reshard()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4266)

При возможности перераспределите набор данных, то есть разделите текущие шарды на большее количество шардов. Это увеличивает число шардов, и в результате num_shards >= previous_num_shards. Равенство возможно, если ни один шард не может быть разделён дальше.

Механизм ресхардирования зависит от формата файла набора данных:

* Parquet: разбивка на шарды по группам строк, а не по файлам
* Vortex: шард на диапазон последовательных чанков (каждый примерно по 64 МБ данных файла), а не на каждый файл
* Другое: пока не реализовано (вклад приветствуется!)

Убедитесь, что операция reshard/shard выполняется перед использованием любого оператора, вносящего случайность (например, `shuffle`). Лучше всего применять оператор sharding на раннем этапе конвейера обработки данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("fancyzhx/amazon_polarity", split="train", streaming=True)
>>> ds
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 4
})
>>> ds.reshard()
IterableDataset({
    features: ['label', 'title', 'content'],
    num_shards: 3600
})
```

#### repeat[[datasets.IterableDataset.repeat]]

```python
repeat(num_times: typing.Optional[int])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4131)

**Параметры:**

num_times (`int`) или (`None`) : Количество повторений набора данных. Если `None`, набор данных будет повторяться бесконечно.

Создайте новый [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset), который повторяет базовый набор данных `num_times` раз.

Пустой вход приводит к завершению даже в том случае, если `num_times` равно `None`.

Примечание. Эффект вызова shuffle после repeat существенно зависит от размера буфера. При buffer_size 1 дублирующиеся данные никогда не встречаются в одной итерации, даже после перемешивания: ds.repeat(n).shuffle(seed=42, buffer_size=1) эквивалентно ds.shuffle(seed=42, buffer_size=1).repeat(n) и перемешивает только порядок шардов внутри каждой итерации. При размере буфера >= (число образцов в наборе данных * num_times) мы получаем полное перемешивание повторенных данных, то есть можем наблюдать дубликаты в одной итерации.

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

#### to_csv[[datasets.IterableDataset.to_csv]]

```python
to_csv(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_csv_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4895)

**Параметры:**

path_or_buf (`PathLike` или `FileOrBuffer`) : Путь к файлу (например, `file.csv`), удалённый URI (например, `hf://datasets/username/my_dataset_name/data.csv`) или объект BinaryIO, в который набор данных будет сохранён в указанном формате.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

- ****to_csv_kwargs** (дополнительные именованные аргументы): параметры, передаваемые в [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) из pandas. Параметр `index` по умолчанию равен `False`, если не указан. Если вы хотите записать индекс, передайте `index=True` и также задайте имя столбца индекса, передав `index_label`.

**Возвращает:** `int`

Количество записанных символов или байтов.

Экспортирует набор данных в csv.

Этот метод итерирует по набору данных и полностью загружает его в память перед записью.

Пример:

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

#### to_pandas[[datasets.IterableDataset.to_pandas]]

```python
to_pandas(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4816)

**Параметры:**

batch_size (`int`, *optional*) : размер (количество строк) батчей, если `batched` равно `True`. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

batched (`bool`) : Установите `True`, чтобы вернуть генератор, выдающий датасет батчами по `batch_size` строк. По умолчанию `False` (возвращает весь датасет сразу).

**Возвращает:**

`pandas.DataFrame` или `Iterator[pandas.DataFrame]`

Возвращает набор данных в виде `pandas.DataFrame`. Также может возвращать генератор для больших наборов данных.

Пример:

```py
>>> ds.to_pandas()
```

#### to_dict[[datasets.IterableDataset.to_dict]]

```python
to_dict(batch_size: typing.Optional[int] = None, batched: bool = False)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4776)

**Параметры:**

batch_size (`int`, *optional*) : размер (количество строк) батчей, если `batched` равно `True`. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

**Возвращает:**

`dict` или `Iterator[dict]`

Возвращает набор данных в виде словаря Python. Также может возвращать генератор для больших наборов данных.

Пример:

```py
>>> ds.to_dict()
```

#### to_json[[datasets.IterableDataset.to_json]]

```python
to_json(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **to_json_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4938)

**Параметры:**

path_or_buf (`PathLike` или `FileOrBuffer`) : Путь к файлу (например, `file.json`), удалённый URI (например, `hf://datasets/username/my_dataset_name/data.json`) или объект BinaryIO, в который набор данных будет сохранён в указанном формате.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

- ****to_json_kwargs** (additional keyword arguments) : Parameters to pass to pandas's [`pandas.DataFrame.to_json`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_json.html). Default arguments are `lines=True` and `orient="records". The parameter `index` defaults to `False` if `orient` is `"split"` or `"table"`. If you would like to write the index, pass `index=True`.

**Возвращает:** `int`

Количество записанных символов или байтов.

Экспортируйте набор данных в JSON Lines или JSON.

Этот метод итерирует по набору данных и полностью загружает его в память перед записью.

Формат вывода по умолчанию — [JSON Lines](https://jsonlines.org/). Чтобы экспортировать в [JSON](https://www.json.org), передайте аргумент `lines=False` и желаемое значение `orient`.

Пример:

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

```py
>>> num_shards = dataset.num_shards
>>> for index in range(num_shards):
...     shard = dataset.shard(index, num_shards)
...     shard.to_json(f"path/of/my/dataset/data-{index:05d}.jsonl")
```

#### to_parquet[[datasets.IterableDataset.to_parquet]]

```python
to_parquet(path_or_buf: typing.Union[str, bytes, os.PathLike, typing.BinaryIO], batch_size: typing.Optional[int] = None, storage_options: typing.Optional[dict] = None, **parquet_writer_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L5034)

**Параметры:**

path_or_buf (`PathLike` или `FileOrBuffer`) : Путь к файлу (например, `file.parquet`), удалённый URI (например, `hf://datasets/username/my_dataset_name/data.parquet`) или объект BinaryIO, в который набор данных будет сохранён в указанном формате.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

storage_options (`dict`, *необязательный*) : Пары ключ/значение, передаваемые в файловую систему, если таковая имеется.

- ****parquet_writer_kwargs** (дополнительные именованные аргументы): параметры для передачи в `pyarrow.parquet.ParquetWriter` PyArrow.

**Возвращает:** `int`

Количество записанных символов или байтов.

Экспортирует набор данных в parquet

Пример:

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

```py
>>> num_shards = dataset.num_shards
>>> for index in range(num_shards):
...     shard = dataset.shard(index, num_shards)
...     shard.to_parquet(f"path/of/my/dataset/data-{index:05d}.parquet")
```

#### to_sql[[datasets.IterableDataset.to_sql]]

```python
to_sql(name: str, con: typing.Union[str, ForwardRef('sqlalchemy.engine.Connection'), ForwardRef('sqlalchemy.engine.Engine'), ForwardRef('sqlite3.Connection')], batch_size: typing.Optional[int] = None, **sql_writer_kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L4992)

**Параметры:**

name (`str`) : Имя таблицы SQL.

con (`str` или `sqlite3.Connection` или `sqlalchemy.engine.Connection` или `sqlalchemy.engine.Connection`) : строка [URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) или объект соединения SQLite3/SQLAlchemy, используемый для записи в базу данных.

batch_size (`int`, *optional*) : Размер батча, который загружается в память и записывается за один раз. По умолчанию `datasets.config.DEFAULT_MAX_BATCH_SIZE`.

- ****sql_writer_kwargs** (дополнительные именованные аргументы): параметры, передаваемые в [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) из pandas. Если параметр `index` не указан, по умолчанию он принимает значение `False`. Чтобы записать индекс, передайте `index=True` и задайте имя столбца индекса, передав `index_label`.

**Возвращает:** `int`

Количество записанных записей.

Экспортирует набор данных в SQL-базу данных.

Пример:

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

#### push_to_hub[[datasets.IterableDataset.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, split: typing.Optional[str] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[int] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L5369)

**Параметры:**

repo_id (`str`) : Идентификатор репозитория, в который выполняется отправка, в формате `<user>/<dataset_name>` или `<org>/<dataset_name>`. Также принимается `<dataset_name>`, в этом случае используется пространство имен текущего пользователя по умолчанию. Также может указываться путь внутри бакета, например `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`, по умолчанию "default") : Имя конфигурации (или подмножества) набора данных. По умолчанию "default".

set_default (`bool`, *необязательный*) : Указывает, следует ли устанавливать эту конфигурацию в качестве конфигурации по умолчанию. В противном случае конфигурацией по умолчанию является та, что называется "default".

split (`str`, *необязательный*) : Имя сплита, которое будет присвоено этому набору данных. По умолчанию — `self.split`.

data_dir (`str`, *необязательный*) : Имя каталога, который будет содержать загруженные файлы данных. По умолчанию используется `config_name`, если он отличается от "default", иначе "data".

commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию — `"Upload dataset"`.

commit_description (`str`, *необязательный*) : Описание коммита, который будет создан. Кроме того, описание PR, если PR будет создан (`create_pr` равно True).

private (`bool`, *optional*) : Указывает, нужно ли сделать репозиторий приватным. Если `None` (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.

token (`str`, *необязательный*) : Необязательный токен аутентификации для Hugging Face Hub. Если токен не передан, по умолчанию будет использован токен, сохранённый локально при входе с помощью `hf auth login`. Если токен не передан и пользователь не вошёл в систему, будет выброшена ошибка.

revision (`str`, *необязательный*) : Ветка, в которую будут отправлены загруженные файлы. По умолчанию используется ветка `"main"`.

create_pr (`bool`, *необязательный*, по умолчанию `False`) : Создавать ли PR с загруженными файлами или коммитить изменения напрямую.

max_shard_size (`int` или `str`, *необязательный*) : Необязательный максимальный размер фрагментов набора данных, загружаемых в хаб. Если указано в виде строки, должно состоять из цифр, за которыми следует единица измерения (например, `"5MB"`). Если не указано, количество фрагментов по умолчанию равно `.num_shards` этого набора данных.

num_shards (`int`, *optional*) : Количество шардов для записи. Если указано `max_shard_size`, а `num_shards` не задано, количество шардов оценивается на основе `max_shard_size`. Может быть больше, чем `.num_shards` данного набора данных: в этом случае каждый входной шард распределяется по нескольким выходным шардам путём записи примеров в них по кругу.

embed_external_files (`bool`, по умолчанию `True`) : Встраивать ли байты файлов в шарды. В частности, перед отправкой для полей следующих типов будут выполнены следующие действия: - [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) и [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image): удалить информацию о локальном пути и встроить содержимое файла в файлы Parquet.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов при подготовке и загрузке набора данных. Это полезно, если набор данных состоит из множества образцов и преобразований. Использует контекст "spawn" для работы с hf_xet, rust-клиентом для быстрой загрузки на HF. Многопоточность отключена по умолчанию.

**Возвращает:**

huggingface_hub.CommitInfo

Отправляет набор данных на хаб в формате Parquet. Набор данных отправляется с помощью HTTP-запросов, поэтому не требуется установка git или git-lfs.

Полученные файлы Parquet по умолчанию являются самодостаточными. Если ваш набор данных содержит данные [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) или [Video](/docs/datasets/main/ru/package_reference/main_classes#datasets.Video), файлы Parquet будут хранить байты ваших изображений или аудиофайлов. Вы можете отключить это, установив `embed_external_files` в `False`.

Пример:

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

Если ваш набор данных содержит несколько разбиений (например, train/validation/test):

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

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

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

#### load_state_dict[[datasets.IterableDataset.load_state_dict]]

```python
load_state_dict(state_dict: dict)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2819)

Загрузите state_dict набора данных. Итерация возобновится с примера, следующего за тем, на котором было сохранено состояние.

Возобновление запускает процесс ровно с того места, где был сохранён контрольный пункт, за исключением двух случаев:

1. примеры из буферов перемешивания теряются при возобновлении, а буферы заполняются новыми данными
2. Сочетания `.with_format(arrow)` и пакетного `.map()` могут приводить к пропуску одной партии.

Пример:

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

который возвращает:
```
{'a': 0}
{'a': 1}
{'a': 2}
checkpoint
restart from checkpoint
{'a': 3}
{'a': 4}
{'a': 5}
```

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

#### state_dict[[datasets.IterableDataset.state_dict]]

```python
state_dict()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2766)

**Возвращает:** `dict`

Получить текущий state_dict набора данных. Он соответствует состоянию на момент последнего сгенерированного примера.

Возобновление запускает процесс ровно с того места, где был сохранён контрольный пункт, за исключением двух случаев:

1. примеры из буферов перемешивания теряются при возобновлении, а буферы заполняются новыми данными
2. Сочетания `.with_format(arrow)` и пакетного `.map()` могут приводить к пропуску одной партии.

Пример:

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

который возвращает:
```
{'a': 0}
{'a': 1}
{'a': 2}
checkpoint
restart from checkpoint
{'a': 3}
{'a': 4}
{'a': 5}
```

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

#### info[[datasets.IterableDataset.info]]

```python
info()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L178)

Объект [DatasetInfo](/docs/datasets/main/ru/package_reference/main_classes#datasets.DatasetInfo), содержащий все метаданные набора данных.

#### split[[datasets.IterableDataset.split]]

```python
split()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L183)

Объект [NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), соответствующий именованной части набора данных.

#### builder_name[[datasets.IterableDataset.builder_name]]

```python
builder_name()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L188)

#### цитирование[[datasets.IterableDataset.citation]]

```python
citation()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L192)

#### config_name[[datasets.IterableDataset.config_name]]

```python
config_name()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L196)

#### dataset_size[[datasets.IterableDataset.dataset_size]]

```python
dataset_size()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L200)

#### Описание[[datasets.IterableDataset.description]]

```python
description()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L204)

#### download_checksums[[datasets.IterableDataset.download_checksums]]

```python
download_checksums()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L208)

#### download_size[[datasets.IterableDataset.download_size]]

```python
download_size()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L212)

#### features[[datasets.IterableDataset.features]]

```python
features()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L216)

#### главная[[datasets.IterableDataset.homepage]]

```python
homepage()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L220)

#### лицензия[[datasets.IterableDataset.license]]

```python
license()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L224)

#### size_in_bytes[[datasets.IterableDataset.size_in_bytes]]

```python
size_in_bytes()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L228)

#### supervised_keys[[datasets.IterableDataset.supervised_keys]]

```python
supervised_keys()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L232)

#### версия[[datasets.IterableDataset.version]]

```python
version()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/arrow_dataset.py#L236)

#### from_csv[[datasets.IterableDataset.from_csv]]

```python
from_csv(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3420)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (пути) к файлу (файлам) CSV.

split ([NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `pandas.read_csv`.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Создание IterableDataset из файла(ов) CSV.

Пример:

```py
>>> ds = IterableDataset.from_csv('path/to/dataset.csv')
```

#### from_json[[datasets.IterableDataset.from_json]]

```python
from_json(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, field: typing.Optional[str] = None, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3463)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (или пути) к файлу (файлам) в формате JSON или JSON Lines.

split ([NamedSplit](/docs/datasets/main/ru/package_reference/builder_classes#datasets.NamedSplit), *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features ([Особенности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features), *необязательный*) : Особенности набора данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

field (`str`, *необязательный*) : Имя поля в JSON-файле, содержащем набор данных.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `JsonConfig`.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Создайте IterableDataset из файла или файлов в формате JSON или JSON Lines.

Пример:

```py
>>> ds = IterableDataset.from_json('path/to/dataset.json')
```

#### from_parquet[[datasets.IterableDataset.from_parquet]]

```python
from_parquet(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, columns: typing.Optional[list[str]] = None, filters: typing.Union[pyarrow._compute.Expression, list[tuple], list[list[tuple]], NoneType] = None, fragment_scan_options: typing.Optional[pyarrow._dataset_parquet.ParquetFragmentScanOptions] = None, on_bad_files: typing.Literal['error', 'warn', 'skip'] = 'error', **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3510)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (пути) к файлу (файлам) Parquet.

split (`NamedSplit`, *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features (`Features`, *необязательный*) : Функции набора данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

columns (`List[str]`, *необязательный*) : Если не `None`, из файла будут прочитаны только эти столбцы. Имя столбца может быть префиксом вложенного поля, например, 'a' выберет 'a.b', 'a.c' и 'a.d.e'.

filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *необязательный*) : Возвращает только строки, соответствующие фильтру. Если возможно, предикат будет передан вниз, чтобы использовать информацию о партициях или внутренние метаданные, найденные в источнике данных, например, статистику Parquet. В противном случае фильтрует загруженные RecordBatches перед их возвратом.

fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *необязательный*) : Параметры, специфичные для сканирования фрагментов Parquet. Это особенно полезно для настройки буферизации и кэширования.

on_bad_files (`Literal["error", "warn", "skip"]`, *необязательный*, по умолчанию "error") : Указывает, что делать при обнаружении повреждённого файла (файла, который невозможно прочитать). Допустимые значения: * 'error' — вызывать исключение при обнаружении повреждённого файла. * 'warn' — выводить предупреждение при обнаружении повреждённого файла и пропускать его. * 'skip' — пропускать повреждённые файлы без вывода предупреждений или вызова исключений.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `ParquetConfig`.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Создание IterableDataset из файла(ов) Parquet.

Пример:

```py
>>> ds = IterableDataset.from_parquet('path/to/dataset.parquet')
```

Загрузка подмножества столбцов:

```python
>>> ds = IterableDataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"])
```

Эффективно фильтруйте данные, при необходимости пропуская целые файлы или группы строк:

```python
>>> filters = [("col_0", "==", 0)]
>>> ds = IterableDataset.from_parquet(parquet_files_list, filters=filters)
```

#### from_text[[datasets.IterableDataset.from_text]]

```python
from_text(path_or_paths: typing.Union[str, bytes, os.PathLike, list[typing.Union[str, bytes, os.PathLike]]], split: typing.Optional[datasets.splits.NamedSplit] = None, features: typing.Optional[datasets.features.features.Features] = None, keep_in_memory: bool = False, keep_linebreaks: bool = False, sample_by: typing.Literal['line', 'paragraph', 'document'] = 'line', **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L3595)

**Параметры:**

path_or_paths (`path-like` или список `path-like`) : Путь (пути) к текстовому файлу (файлам).

split (`NamedSplit`, *необязательный*) : Имя сплита, которое будет присвоено набору данных.

features (`Features`, *необязательный*) : Функции набора данных.

keep_in_memory (`bool`, по умолчанию `False`) : Копировать ли данные в оперативной памяти.

keep_linebreaks : (`bool`, по умолчанию False): Сохранять ли переносы строк.

sample_by (`Literal["line", "paragraph", "document"]`, по умолчанию "line") : Загружать данные построчно, по абзацам или по документам. По умолчанию одна строка в наборе данных соответствует одной строке текста.

- ****kwargs** (дополнительные именованные аргументы) : Именованные аргументы, передаваемые в `TextConfig`.

**Возвращает:**

[IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset)

Создайте IterableDataset из текстового файла или файлов.

Пример:

```py
>>> ds = IterableDataset.from_text('path/to/dataset.txt')
```

#### datasets.IterableColumn[[datasets.IterableColumn]]

```python
datasets.IterableColumn(source: typing.Union[ForwardRef('IterableDataset'), ForwardRef('IterableColumn')], column_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/iterable_dataset.py#L2676)

Итерируемый объект для конкретного столбца [IterableDataset](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset).

Пример:

Итерация по значениям столбца "text" набора данных:

```python
for text in dataset["text"]:
    ...
```

Он также работает с вложенными столбцами:

```python
for source in dataset["metadata"]["source"]:
    ...
```

## IterableDatasetDict[[datasets.IterableDatasetDict]]

Словарь, в котором ключами являются имена разбиений (например, 'train', 'test'), а значениями — объекты `IterableDataset`.

#### datasets.IterableDatasetDict[[datasets.IterableDatasetDict]]

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1847)

#### map[[datasets.IterableDatasetDict.map]]

```python
map(function: typing.Optional[typing.Callable] = None, with_indices: bool = False, with_split: bool = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: int = 1000, drop_last_batch: bool = False, remove_columns: typing.Union[str, list[str], NoneType] = None, fn_kwargs: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1948)

**Параметры:**

function (`Callable`, *необязательный*, по умолчанию `None`) : Функция, применяемая на лету к примерам при итерации по набору данных. Она должна иметь одну из следующих сигнатур:  - `function(example: Dict[str, Any]) -> Dict[str, Any]`, если `batched=False` и `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]`, если `batched=False` и `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]`, если `batched=True` и `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]`, если `batched=True` и `with_indices=True`  Для расширенного использования функция также может возвращать `pyarrow.Table`. Если функция асинхронная, `map` выполнит её параллельно. Кроме того, если функция ничего не возвращает (`None`), `map` выполнит её и вернёт набор данных без изменений. Если функция не задана, используется функция тождественного отображения: `lambda x: x`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx[, rank]): ...`.

input_columns (`[Union[str, list[str]]]`, *необязательный*, по умолчанию `None`) : Столбцы, которые передаются в `function` в качестве позиционных аргументов. Если указано `None`, в качестве одного аргумента передаётся словарь, отображающий все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`.

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched=True`.

drop_last_batch (`bool`, по умолчанию `False`) : следует ли отбрасывать последний батч, если его размер меньше `batch_size`, вместо того чтобы обрабатывать его функцией.

remove_columns (`[list[str]]`, *необязательный*, по умолчанию `None`) : Удаляет выбранные столбцы во время выполнения отображения. Столбцы удаляются до обновления примеров с помощью вывода `function`, то есть если `function` добавляет столбцы с именами из `remove_columns`, эти столбцы будут сохранены.

fn_kwargs (`Dict`, *необязательный*, по умолчанию `None`) : Именованные аргументы, передаваемые в `function`

Применяет функцию ко всем примерам в итерируемом наборе данных (по отдельности или партиями) и обновляет их. Если функция возвращает столбец, который уже существует, он перезаписывается. Функция применяется на лету к примерам при итерации по набору данных. Преобразование применяется ко всем наборам данных в словаре наборов данных.

Вы можете указать, должна ли функция обрабатываться батчами или нет, с помощью параметра `batched`:

- Если `False`, функция принимает один пример и должна вернуть один пример. Примером является словарь, например `{"text": "Hello there !"}`.
- If batched is `True` and `batch_size` is 1, then the function takes a batch of 1 example as input and can return a batch with 1 or more examples. A batch is a dictionary, e.g. a batch of 1 example is `{"text": ["Hello there !"]}`.
- Если `True` и `batch_size` равно `n` > 1, функция принимает на вход батч из `n` примеров и может вернуть батч из `n` примеров или произвольного количества примеров. Обратите внимание, что в последнем батче может быть меньше `n` примеров. Батч — это словарь, например, батч из `n` примеров имеет вид `{"text": ["Hello there !"] * n}`.

Если функция асинхронная, то `map` будет выполнять её параллельно, с максимумом в тысячу одновременных вызовов. Рекомендуется использовать `asyncio.Semaphore` в вашей функции, если вы хотите задать максимальное количество операций, которые могут выполняться одновременно.

Пример:

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

#### фильтр[[datasets.IterableDatasetDict.filter]]

```python
filter(function: typing.Optional[typing.Callable] = None, with_indices = False, input_columns: typing.Union[str, list[str], NoneType] = None, batched: bool = False, batch_size: typing.Optional[int] = 1000, fn_kwargs: typing.Optional[dict] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2048)

**Параметры:**

function (`Callable`) : Вызываемый объект с одной из следующих сигнатур:  - `function(example: Dict[str, Any]) -> bool`, если `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool`, если `with_indices=True, batched=False` - `function(example: Dict[str, list]) -> list[bool]`, если `with_indices=False, batched=True` - `function(example: Dict[str, list], indices: list[int]) -> list[bool]`, если `with_indices=True, batched=True`  Если функция не указана, по умолчанию используется функция, всегда возвращающая True: `lambda x: True`.

with_indices (`bool`, по умолчанию `False`) : Передавать индексы примеров в `function`. Обратите внимание, что в этом случае сигнатура `function` должна быть `def function(example, idx): ...`.

input_columns (`str` или `list[str]`, *необязательный*) : Столбцы, которые передаются в `function` как позиционные аргументы. Если `None`, в качестве одного аргумента передаётся словарь, отображающий все отформатированные столбцы.

batched (`bool`, по умолчанию `False`) : Передавать пакет примеров в `function`

batch_size (`int`, *необязательный*, по умолчанию `1000`) : Количество примеров в каждой партии, передаваемых в `function`, если `batched=True`.

fn_kwargs (`Dict`, *необязательный*, по умолчанию `None`) : Именованные аргументы, передаваемые в `function`

Примените функцию фильтрации ко всем элементам, чтобы в наборе данных оставались только примеры, удовлетворяющие условию фильтрации. Фильтрация выполняется на лету при итерации по набору данных. Фильтрация применяется ко всем наборам данных в словаре наборов данных.

Пример:

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

#### shuffle[[datasets.IterableDatasetDict.shuffle]]

```python
shuffle(seed = None, generator: typing.Optional[numpy.random._generator.Generator] = None, buffer_size: int = 1000, max_buffer_input_shards: int = 10)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2111)

**Параметры:**

seed (`int`, *необязательный*, по умолчанию `None`) : Случайное зерно, которое будет использоваться для перемешивания набора данных. Оно применяется для выборки из буфера перемешивания, а также для перемешивания фрагментов данных.

generator (`numpy.random.Generator`, *optional*) : Генератор случайных чисел Numpy, используемый для вычисления перестановки строк набора данных. Если `generator=None` (по умолчанию), используется `np.random.default_rng` (генератор битов по умолчанию (PCG64) в NumPy).

buffer_size (`int`, по умолчанию `1000`) : Размер буфера.

max_buffer_input_shards (`int`, по умолчанию `10`) : Максимальное количество шардов, используемых для заполнения буфера за один раз.

Случайным образом перемешивает элементы этого набора данных. Перемешивание применяется ко всем наборам данных в словаре наборов данных.

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

Например, если ваш набор данных содержит 10 000 элементов, но `buffer_size` установлен в 1000, то `shuffle` сначала выберет случайный элемент только из первых 1000 элементов в буфере. После выбора элемента его место в буфере заменяется следующим (т. е. 1001-м) элементом, что поддерживает буфер из 1000 элементов.

Если датасет состоит из нескольких шардов, он также выполняет `shuffle` для порядка шардов. Однако, если порядок был зафиксирован с помощью [skip()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.skip) или [take()](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDataset.take), порядок шардов остаётся неизменным.

Пример:

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

#### with_format[[datasets.IterableDatasetDict.with_format]]

```python
with_format(type: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L1902)

**Параметры:**

type (`str`, *необязательный*) : Тип вывода, выбранный из `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` означает, что возвращаются объекты Python (по умолчанию).

Возвращает набор данных в указанном формате.

Пример:

```py
>>> from datasets import load_dataset
>>> from transformers import AutoTokenizer
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation", streaming=True)
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
>>> ds = ds.map(lambda x: tokenizer(x['text'], truncation=True, padding=True), batched=True)
>>> ds = ds.with_format("torch")
>>> next(iter(ds))
{'text': 'compassionately explores the seemingly irreconcilable situation between conservative christian parents and their estranged gay and lesbian children .',
 'label': tensor(1),
 'input_ids': tensor([  101, 18027, 16310, 16001,  1103,  9321,   178, 11604,  7235,  6617,
        1742,  2165,  2820,  1206,  6588, 22572, 12937,  1811,  2153,  1105,
        1147, 12890, 19587,  6463,  1105, 15026,  1482,   119,   102,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
            0,     0,     0,     0]),
 'token_type_ids': tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
 'attention_mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])}
```

#### cast[[datasets.IterableDatasetDict.cast]]

```python
cast(features: Features)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2327)

**Параметры:**

features (`Features`) : Новые признаки, к которым нужно привести набор данных. Имена полей в признаках должны совпадать с текущими именами столбцов. Тип данных также должен допускать преобразование из одного типа в другой. Для нетривиальных преобразований, например `string` <-> `ClassLabel`, следует использовать `map` для обновления Dataset.

**Возвращает:** [IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict)

Копия набора данных с преобразованными признаками.

Приведите набор данных к новому набору признаков. Преобразование типов применяется ко всем наборам данных в словаре наборов данных.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> new_features = ds["train"].features.copy()
>>> new_features['label'] = ClassLabel(names=['bad', 'good'])
>>> new_features['text'] = Value('large_string')
>>> ds = ds.cast(new_features)
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('large_string')}
```

#### cast_column[[datasets.IterableDatasetDict.cast_column]]

```python
cast_column(column: str, feature: typing.Union[dict, list, tuple, datasets.features.features.Value, datasets.features.features.ClassLabel, datasets.features.translation.Translation, datasets.features.translation.TranslationVariableLanguages, datasets.features.features.LargeList, datasets.features.features.List, datasets.features.features.Array2D, datasets.features.features.Array3D, datasets.features.features.Array4D, datasets.features.features.Array5D, datasets.features.audio.Audio, datasets.features.image.Image, datasets.features.mesh.Mesh, datasets.features.video.Video, datasets.features.pdf.Pdf, datasets.features.nifti.Nifti, datasets.features.bio_sequence.BioSequence, datasets.features.bio_structure.BioStructure])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2296)

**Параметры:**

column (`str`) : Имя столбца.

feature (`Feature`) : Целевая переменная.

**Возвращает:**

[IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict)

Приведение столбца к типу feature для декодирования. Преобразование типа применяется ко всем наборам данных в словаре наборов данных.

Пример:

```py
>>> from datasets import load_dataset, ClassLabel
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", streaming=True)
>>> ds["train"].features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
>>> ds = ds.cast_column('label', ClassLabel(names=['bad', 'good']))
>>> ds["train"].features
{'label': ClassLabel(names=['bad', 'good']),
 'text': Value('string')}
```

#### remove_columns[[datasets.IterableDatasetDict.remove_columns]]

```python
remove_columns(column_names: typing.Union[str, list[str]])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2244)

**Параметры:**

column_names (`Union[str, list[str]]`) : Имя столбца (столбцов) для удаления.

**Возвращает:** [IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict)

Копия объекта набора данных без удаляемых столбцов.

Удаляет одну или несколько колонок в наборе данных, а также связанные с ними признаки. Удаление выполняется на лету для примеров при итерации по набору данных. Удаление применяется ко всем наборам данных в словаре наборов данных.

Пример:

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

#### rename_column[[datasets.IterableDatasetDict.rename_column]]

```python
rename_column(original_column_name: str, new_column_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2180)

**Параметры:**

original_column_name (`str`) : Имя переименовываемой колонки.

new_column_name (`str`) : Новое имя столбца.

**Возвращает:** [IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict)

Копия набора данных с переименованной колонкой.

Переименование столбца в наборе данных и перемещение признаков, связанных с исходным столбцом, под новое имя столбца. Переименование применяется ко всем наборам данных в словаре наборов данных.

Пример:

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

#### rename_columns[[datasets.IterableDatasetDict.rename_columns]]

```python
rename_columns(column_mapping: dict)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2216)

**Параметры:**

column_mapping (`Dict[str, str]`) : Соответствие столбцов, которые нужно переименовать, и их новых имён.

**Возвращает:** [IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict)

Копия набора данных с переименованными столбцами

Переименовать несколько столбцов в наборе данных и переместить признаки, связанные с исходными столбцами, под новыми именами столбцов. Переименование применяется ко всем наборам данных в словаре наборов данных.

Пример:

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

#### select_columns[[datasets.IterableDatasetDict.select_columns]]

```python
select_columns(column_names: typing.Union[str, list[str]])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2270)

**Параметры:**

column_names (`Union[str, list[str]]`) : Имя столбца (столбцов), который нужно сохранить.

**Возвращает:** [IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict)

Копия объекта набора данных, содержащая только выбранные столбцы.

Выберите одну или несколько колонок в наборе данных, а также связанные с ними признаки. Выбор выполняется на лету для примеров при итерации по набору данных. Выбор применяется ко всем наборам данных в словаре наборов данных.

Пример:

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

#### push_to_hub[[datasets.IterableDatasetDict.push_to_hub]]

```python
push_to_hub(repo_id: str, config_name: str = 'default', set_default: typing.Optional[bool] = None, data_dir: typing.Optional[str] = None, commit_message: typing.Optional[str] = None, commit_description: typing.Optional[str] = None, private: typing.Optional[bool] = None, token: typing.Optional[str] = None, revision: typing.Optional[str] = None, create_pr: typing.Optional[bool] = False, max_shard_size: typing.Union[str, int, NoneType] = None, num_shards: typing.Optional[dict[str, int]] = None, embed_external_files: bool = True, num_proc: typing.Optional[int] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/dataset_dict.py#L2364)

**Параметры:**

repo_id (`str`) : Идентификатор репозитория, в который выполняется отправка, в формате `<user>/<dataset_name>` или `<org>/<dataset_name>`. Также принимается `<dataset_name>`, в этом случае используется пространство имен текущего пользователя по умолчанию. Также может указываться путь внутри бакета, например `buckets/<user_or_org>/<bucket_name>/...`

config_name (`str`) : Имя конфигурации набора данных. По умолчанию — "default".

set_default (`bool`, *необязательный*) : Указывает, следует ли устанавливать эту конфигурацию в качестве конфигурации по умолчанию. В противном случае конфигурацией по умолчанию является та, что называется "default".

data_dir (`str`, *необязательный*) : Имя каталога, который будет содержать загруженные файлы данных. По умолчанию используется `config_name`, если он отличается от "default", иначе "data".

commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию — `"Upload dataset"`.

commit_description (`str`, *необязательный*) : Описание коммита, который будет создан. Кроме того, описание PR, если PR будет создан (`create_pr` равно True).

private (`bool`, *optional*) : Указывает, нужно ли сделать репозиторий приватным. Если `None` (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.

token (`str`, *необязательный*) : Необязательный токен аутентификации для Hugging Face Hub. Если токен не передан, по умолчанию будет использован токен, сохранённый локально при входе с помощью `hf auth login`. Если токен не передан и пользователь не вошёл в систему, будет выброшена ошибка.

revision (`str`, *необязательный*) : Ветка, в которую будут отправлены загруженные файлы. По умолчанию используется ветка `"main"`.

create_pr (`bool`, *необязательный*, по умолчанию `False`) : Создавать ли PR с загруженными файлами или коммитить изменения напрямую.

max_shard_size (`int` или `str`, *необязательный*) : Необязательный максимальный размер фрагментов набора данных, загружаемых в хаб. Если указано в виде строки, должно состоять из цифр, за которыми следует единица измерения (например, `"500MB"` или `"1GB"`). Если не указано, каждый сплит сохраняет исходное количество фрагментов набора данных.

num_shards (`Dict[str, int]`, *необязательный*) : Количество шардов для записи. Используйте словарь, чтобы задать разное значение `num_shards` для каждого сплита. Если указано `max_shard_size`, а для сплита не задано `num_shards`, то количество шардов для этого сплита оценивается на основе `max_shard_size`.

embed_external_files (`bool`, по умолчанию `True`) : Встраивать ли байты файлов в шарды. В частности, перед отправкой для полей следующих типов: - [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) и [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image) — удаляется информация о локальном пути, а содержимое файла встраивается в файлы Parquet.

num_proc (`int`, *optional*, по умолчанию `None`) : Количество процессов при подготовке и загрузке набора данных. Это полезно, если набор данных состоит из множества образцов или медиафайлов для встраивания. Использует контекст "spawn" для работы с hf_xet, rust-клиентом для быстрой загрузки на HF. Многопроцессность по умолчанию отключена.

**Возвращает:**

huggingface_hub.CommitInfo

Отправляет [IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict) на хаб в формате Parquet. [IterableDatasetDict](/docs/datasets/main/ru/package_reference/main_classes#datasets.IterableDatasetDict) отправляется с помощью HTTP-запросов, поэтому не требуется установка git или git-lfs.

Каждый раздел набора данных будет загружен независимо. Загруженный набор данных сохранит исходные имена разделов.

Полученные файлы Parquet по умолчанию являются самодостаточными: если ваш набор данных содержит данные [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image) или [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio), файлы Parquet будут хранить байты ваших изображений или аудиофайлов. Вы можете отключить это, установив `embed_external_files` в False.

Пример:

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

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

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

## Возможности[[datasets.Features]]

#### datasets.Features[[datasets.Features]]

```python
datasets.Features(*args, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1932)

Специальный словарь, определяющий внутреннюю структуру набора данных.

Создаётся с использованием словаря типа `dict[str, FieldType]`, где ключи — это желаемые имена столбцов, а значения — типы соответствующих столбцов.

`FieldType` может принимать одно из следующих значений:
- Функция [Value](/docs/datasets/main/ru/package_reference/main_classes#datasets.Value) указывает значение одного типа данных, например `int64` или `string`.
- Функция [ClassLabel](/docs/datasets/main/ru/package_reference/main_classes#datasets.ClassLabel) определяет заранее заданный набор классов, для которых можно назначить метки, и хранит их в наборе данных в виде целых чисел.
- Python `dict` задаёт составную характеристику, содержащую отображение подполей на подхарактеристики. Можно иметь вложенные поля произвольным образом.
- [List](/docs/datasets/main/ru/package_reference/main_classes#datasets.List) или [LargeList](/docs/datasets/main/ru/package_reference/main_classes#datasets.LargeList) задаёт составную характеристику, содержащую последовательность подхарактеристик, все одного и того же типа.
- Функция [Array2D](/docs/datasets/main/ru/package_reference/main_classes#datasets.Array2D), [Array3D](/docs/datasets/main/ru/package_reference/main_classes#datasets.Array3D), [Array4D](/docs/datasets/main/ru/package_reference/main_classes#datasets.Array4D) или [Array5D](/docs/datasets/main/ru/package_reference/main_classes#datasets.Array5D) для многомерных массивов.
- Функция [Audio](/docs/datasets/main/ru/package_reference/main_classes#datasets.Audio) для хранения абсолютного пути к аудиофайлу или словаря с относительным путём к аудиофайлу (ключ "path") и его содержимым в байтах (ключ "bytes"). Эта функция загружает аудио лениво с помощью декодера.
- Функция [Image](/docs/datasets/main/ru/package_reference/main_classes#datasets.Image) для хранения абсолютного пути к файлу изображения, объекта `np.ndarray`, объекта `PIL.Image.Image` или словаря с относительным путём к файлу изображения (ключ "path") и его содержимым в байтах (ключ "bytes"). Эта функция извлекает данные изображения.
- Функция [Video](/docs/datasets/main/ru/package_reference/main_classes#datasets.Video) для хранения абсолютного пути к файлу видео, объекта `torchcodec.decoders.VideoDecoder` или словаря с относительным путём к файлу видео (ключ "path") и его содержимым в байтах (ключ "bytes"). Эта функция загружает видео лениво с помощью декодера.
- [Pdf](/docs/datasets/main/ru/package_reference/main_classes#datasets.Pdf) — функция для хранения абсолютного пути к файлу PDF, объекта `pdfplumber.pdf.PDF` или словаря с относительным путём к файлу PDF (ключ "path") и его содержимым в виде байтов (ключ "bytes"). Эта функция загружает PDF лениво с помощью PDF-ридера.
- [Nifti](/docs/datasets/main/ru/package_reference/main_classes#datasets.Nifti) — функция для хранения абсолютного пути к файлу нейровизуализации в формате NIfTI, объекта `nibabel.Nifti1Image` или словаря с относительным путём к файлу NIfTI (ключ "path") и его содержимым в виде байтов (ключ "bytes"). Эта функция загружает файл NIfTI лениво с помощью nibabel.
- Функция [Translation](/docs/datasets/main/ru/package_reference/main_classes#datasets.Translation) или [TranslationVariableLanguages](/docs/datasets/main/ru/package_reference/main_classes#datasets.TranslationVariableLanguages), специфичная для машинного перевода.
- Функция [Json](/docs/datasets/main/ru/package_reference/loading_methods#datasets.Json) для хранения неструктурированных данных, например, содержащих смешанные/произвольные типы. Под капотом

#### копировать[[datasets.Features.copy]]

```python
copy()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2376)

**Возвращает:**

[Возможности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features)

Создайте глубокую копию [Features](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features).

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> copy_of_features = ds.features.copy()
>>> copy_of_features
{'label': ClassLabel(names=['neg', 'pos']),
 'text': Value('string')}
```

#### decode_batch[[datasets.Features.decode_batch]]

```python
decode_batch(batch: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2349)

**Параметры:**

batch (`dict[str, list[Any]]`) : данные батча датасета.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к аудио- или изображений-файлам из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (str) -> token (bool or str)

**Возвращает:**

`dict[str, list[Any]]`

Декодирование батча с кастомным декодированием признаков.

#### decode_column[[datasets.Features.decode_column]]

```python
decode_column(column: list, column_name: str, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2324)

**Параметры:**

column (`list[Any]`) : данные столбца датасета.

column_name (`str`) : Имя столбца набора данных.

**Возвращает:**

`list[Any]`

Декодирование столбца с пользовательским декодированием признаков.

#### decode_example[[datasets.Features.decode_example]]

```python
decode_example(example: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2301)

**Параметры:**

example (`dict[str, Any]`) : данные строки набора данных.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к аудио- или изображений-файлам из частных репозиториев на Hub и декодировать их, можно передать словарь `repo_id (str) -> token (bool or str)`.

**Возвращает:**

`dict[str, Any]`

Пример декодирования с пользовательским декодированием признаков.

#### encode_batch[[datasets.Features.encode_batch]]

```python
encode_batch(batch)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2282)

**Параметры:**

batch (`dict[str, list[Any]]`) : Данные в батче Dataset.

**Возвращает:**

`dict[str, list[Any]]`

Кодирует пакет в формат Arrow.

#### encode_column[[datasets.Features.encode_column]]

```python
encode_column(column, column_name: str)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2255)

**Параметры:**

column (`list[Any]` или `np.ndarray`) : данные в столбце Dataset.

column_name (`str`) : Имя столбца набора данных.

**Возвращает:**

`list[Any]` или `np.ndarray`

Кодирование столбца в формат Arrow.

#### encode_example[[datasets.Features.encode_example]]

```python
encode_example(example)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2241)

**Параметры:**

example (`dict[str, Any]`) : Данные в строке Dataset.

**Возвращает:**

`dict[str, Any]`

Кодирует пример в формат Arrow.

#### flatten[[datasets.Features.flatten]]

```python
flatten(max_depth = 16)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2449)

**Возвращает:** [Features](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features)

Сплющенные признаки.

Выравнивание признаков. Каждая столбец-словарь удаляется и заменяется всеми содержащимися в нём подполями. Новые поля получают имена, образованные конкатенацией имени исходного столбца и имени подполя в формате `<original>.<subfield>`.

Если столбец содержит вложенные словари, то имена всех подполей нижнего уровня также конкатенируются для формирования новых столбцов: `<original>.<subfield>.<subsubfield>` и т. д.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("rajpurkar/squad", split="train")
>>> ds.features.flatten()
{'answers.answer_start': List(Value('int32'), id=None),
 'answers.text': List(Value('string'), id=None),
 'context': Value('string'),
 'id': Value('string'),
 'question': Value('string'),
 'title': Value('string')}
```

#### from_arrow_schema[[datasets.Features.from_arrow_schema]]

```python
from_arrow_schema(pa_schema: Schema)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2024)

**Параметры:**

pa_schema (`pyarrow.Schema`) : Схема Arrow.

**Возвращает:**

[Возможности](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features)

Создаёт [Features](/docs/datasets/main/ru/package_reference/main_classes#datasets.Features) из схемы Arrow. Также проверяет метаданные схемы на наличие признаков Hugging Face Datasets. Ненулевые поля не поддерживаются и устанавливаются как допускающие null.

Также pa.dictionary не поддерживается, и вместо него используется его базовый тип. Поэтому datasets преобразует объекты DictionaryArray в их фактические значения.

#### from_dict[[datasets.Features.from_dict]]

```python
from_dict(dic)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2058)

**Параметры:**

dic (*dict[str, Any]*) : словарь Python.

**Возвращает:** `*Features*`

Создание [*Features*] из словаря.

Восстановите вложенный объект признака из десериализованного словаря. Мы используем ключ *_type* для определения имени dataclass типа признака *FieldType*.

Это позволяет использовать удобную синтаксис конструктора для определения признаков из десериализованных JSON-словарей. Эта функция используется в частности при десериализации [*DatasetInfo*], который был сохранён в JSON-объект. Она выступает аналогом [*Features.from_arrow_schema*] и обрабатывает рекурсивную поэлементную инициализацию, но не требует никакого отображения в pyarrow и обратно, за исключением того, что использует отображение примитивных типов данных pyarrow, которое [*Value*] выполняет автоматически.

Пример:

```python
>>> Features.from_dict(&amp;lcub;'_type': &amp;lcub;'dtype': 'string', 'id': None, '_type': 'Value'}})
&amp;lcub;'_type': Value('string')}
```

#### reorder_fields_as[[datasets.Features.reorder_fields_as]]

```python
reorder_fields_as(other: Features)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L2396)

**Параметры:**

other ([*Возможности*]) : Другие [*возможности*], с которыми нужно согласовать.

**Возвращает:**

[*Возможности*]

Измените порядок полей Features, чтобы он соответствовал порядку полей в других [*Features*].

Порядок полей имеет значение, поскольку он влияет на базовые данные arrow. Изменение порядка полей позволяет привести базовый тип данных arrow в соответствие.

Пример:

```python
>>> from datasets import Features, List, Value
>>> # let's say we have two features with a different order of nested fields (for a and b for example)
>>> f1 = Features(&amp;lcub;"root": &amp;lcub;"a": Value("string"), "b": Value("string")}})
>>> f2 = Features(&amp;lcub;"root": &amp;lcub;"b": Value("string"), "a": Value("string")}})
>>> assert f1.type != f2.type
>>> # re-ordering keeps the base structure (here List is defined at the root level), but makes the fields order match
>>> f1.reorder_fields_as(f2)
&amp;lcub;'root': List(&amp;lcub;'b': Value('string'), 'a': Value('string')})}
>>> assert f1.reorder_fields_as(f2).type == f2.type
```

### Скаляр[[datasets.Value]]

#### datasets.Value[[datasets.Value]]

```python
datasets.Value(dtype: str, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L511)

**Параметры:**

dtype (`str`) : Имя типа данных.

Скалярное значение признака определённого типа данных.

Возможные типы `Value` следующие:
- `null`
- `bool`
- `int8`
- `int16`
- `int32`
- `int64`
- `uint8`
- `uint16`
- `uint32`
- `uint64`
- `float16`
- `float32` (псевдоним float)
- `float64` (псевдоним double)
- `time32[(s|ms)]`
- `time64[(us|ns)]`
- `timestamp[(s|ms|us|ns)]`
- `timestamp[(s|ms|us|ns), tz=(tzstring)]`
- `date32`
- `date64`
- `duration[(s|ms|us|ns)]`
- `decimal128(precision, scale)`
- `decimal256(precision, scale)`
- `binary`
- `large_binary`
- `binary_view`
- `string`
- `large_string`
- `string_view`

Пример:

```py
>>> from datasets import Features
>>> features = Features({'stars': Value('int32')})
>>> features
{'stars': Value('int32')}
```

#### datasets.ClassLabel[[datasets.ClassLabel]]

```python
datasets.ClassLabel(num_classes: dataclasses.InitVar[typing.Optional[int]] = None, names: list = None, names_file: dataclasses.InitVar[typing.Optional[str]] = None, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1052)

**Параметры:**

num_classes (`int`, *optional*) : Количество классов. Все метки должны быть < `num_classes`.

names (`list` из `str`, *необязательный*) : Строковые имена для целочисленных классов. Порядок, в котором указаны имена, сохраняется.

names_file (`str`, *необязательный*) : Путь к файлу с названиями целочисленных классов, по одному на строку.

Тип признака для целочисленных меток классов.

Существует 3 способа определить `ClassLabel`, которые соответствуют 3 аргументам:

* `num_classes`: Создаёт метки от 0 до (num_classes-1).
* `names`: список строк с метками.
* `names_file`: файл, содержащий список меток.

Внутри метки хранятся в виде целых чисел. Для представления неизвестных или отсутствующих меток можно использовать значение -1.

Пример:

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

#### cast_storage[[datasets.ClassLabel.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.IntegerArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1217)

**Параметры:**

storage (`Union[pa.StringArray, pa.IntegerArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.Int64Array`

Массив в типе хранения arrow `ClassLabel`.

Преобразование Arrow-массива в тип хранения `ClassLabel` для arrow. Типы Arrow, которые можно преобразовать в тип хранения pyarrow `ClassLabel`:

- `pa.string()`
- `pa.int()`

#### int2str[[datasets.ClassLabel.int2str]]

```python
int2str(values: typing.Union[int, collections.abc.Iterable])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1171)

Преобразование `integer` => строка имени класса `string`.

Что касается неизвестных/отсутствующих меток: передача отрицательных целых чисел вызывает `ValueError`.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> ds.features["label"].int2str(0)
'neg'
```

#### str2int[[datasets.ClassLabel.str2int]]

```python
str2int(values: typing.Union[str, collections.abc.Iterable])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1126)

Имя класса преобразования `string` => `integer`.

Пример:

```py
>>> from datasets import load_dataset
>>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train")
>>> ds.features["label"].str2int('neg')
0
```

### Композитный[[datasets.LargeList]]

#### datasets.LargeList[[datasets.LargeList]]

```python
datasets.LargeList(feature: typing.Any, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1414)

**Параметры:**

feature (`FeatureType`) : Тип данных дочерней функции для каждого элемента в большом списке.

Тип признака для данных в виде большого списка, состоящего из данных дочернего типа признака.

Она основана на `pyarrow.LargeListType`, который похож на `pyarrow.ListType`, но использует 64-битные, а не 32-битные смещения.

#### datasets.List[[datasets.List]]

```python
datasets.List(feature: typing.Any, length: int = -1, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1386)

**Параметры:**

feature (`FeatureType`) : Тип данных дочерней функции для каждого элемента в большом списке.

length (необязательный `int`, по умолчанию -1) : Длина списка, если она фиксирована. По умолчанию -1, что означает произвольную длину.

Тип признака для данных в виде большого списка, состоящего из данных дочернего типа признака.

Она основана на `pyarrow.ListType`, который использует 32-битные смещения или фиксированную длину.

#### datasets.Sequence[[datasets.Sequence]]

```python
datasets.Sequence(feature = None, length = -1, **kwargs)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1352)

**Параметры:**

feature (`FeatureType`) : Тип данных дочерней функции для каждого элемента в большом списке.

length (необязательный `int`, по умолчанию -1) : Длина списка, если она фиксирована. По умолчанию -1, что означает произвольную длину.

**Возвращает:**

[Список](/docs/datasets/main/ru/package_reference/main_classes#datasets.List) указанного признака, за исключением `dict` подпризнаков, которые преобразуются в `dict` списков подпризнаков для совместимости с TFDS.

`Sequence` — это утилита, которая автоматически преобразует внутреннюю словарную характеристику в словарь списков. Такое поведение реализовано для обеспечения совместимости с библиотекой TensorFlow Datasets, но в некоторых случаях может быть нежелательным. Если вам не нужно такое поведение, используйте [List](/docs/datasets/main/ru/package_reference/main_classes#datasets.List) или [LargeList](/docs/datasets/main/ru/package_reference/main_classes#datasets.LargeList) вместо [Sequence](/docs/datasets/main/ru/package_reference/main_classes#datasets.Sequence).

### Перевод[[datasets.Translation]]

#### datasets.Translation[[datasets.Translation]]

```python
datasets.Translation(languages: list, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L12)

**Параметры:**

languages (`dict`) : Словарь для каждого примера, сопоставляющий строковые коды языков со строковыми переводами.

`Feature` для переводов с фиксированными языками для каждого примера. Здесь для совместимости с tfds.

Пример:

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

#### flatten[[datasets.Translation.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L44)

Разверните функцию Translation в словарь.

#### datasets.TranslationVariableLanguages[[datasets.TranslationVariableLanguages]]

```python
datasets.TranslationVariableLanguages(languages: typing.Optional[list] = None, num_languages: typing.Optional[int] = None, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L52)

**Параметры:**

languages (`dict`) : Словарь для каждого примера, сопоставляющий строковые коды языков с одной или несколькими строковыми переводами. Набор языков может различаться от примера к примеру.

**Возвращает:** - `language` или `translation` (одномерный `tf.Tensor` переменной длины типа `tf.string`)

Коды языков, отсортированные по возрастанию, или переводы в обычном тексте, отсортированные для соответствия кодам языков.

`Feature` для переводов с переменными языками для каждого примера. Здесь для совместимости с tfds.

Пример:

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

#### flatten[[datasets.TranslationVariableLanguages.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/translation.py#L122)

Разверните функцию TranslationVariableLanguages в словарь.

### Массивы[[datasets.Array2D]]

#### datasets.Array2D[[datasets.Array2D]]

```python
datasets.Array2D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L608)

**Параметры:**

shape (`tuple`) : Размер каждого измерения.

dtype (`str`) : Имя типа данных.

Создайте двумерный массив.

Пример:

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

#### datasets.Array3D[[datasets.Array3D]]

```python
datasets.Array3D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L633)

**Параметры:**

shape (`tuple`) : Размер каждого измерения.

dtype (`str`) : Имя типа данных.

Создайте трёхмерный массив.

Пример:

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

#### datasets.Array4D[[datasets.Array4D]]

```python
datasets.Array4D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L658)

**Параметры:**

shape (`tuple`) : Размер каждого измерения.

dtype (`str`) : Имя типа данных.

Создайте четырёхмерный массив.

Пример:

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

#### datasets.Array5D[[datasets.Array5D]]

```python
datasets.Array5D(shape: tuple, dtype: str, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L683)

**Параметры:**

shape (`tuple`) : Размер каждого измерения.

dtype (`str`) : Имя типа данных.

Создайте пятимерный массив.

Пример:

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

### Аудио[[datasets.Audio]]

#### datasets.Audio[[datasets.Audio]]

```python
datasets.Audio(sampling_rate: typing.Optional[int] = None, decode: bool = True, num_channels: typing.Optional[int] = None, stream_index: typing.Optional[int] = None, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L24)

**Параметры:**

sampling_rate (`int`, *optional*) : Целевая частота дискретизации. Если `None`, используется исходная частота дискретизации.

num_channels (`int`, *optional*) : Требуемое количество каналов в выборках. По умолчанию используется количество каналов источника. Декодирование аудио возвращает выборки с формой (num_channels, num_samples). В настоящее время поддерживаются `None` (количество каналов источника, по умолчанию), `1` (моно) или `2` (стерео) канала. Аргумент `num_channels` передается в `torchcodec.decoders.AudioDecoder`.

decode (`bool`, по умолчанию `True`) : Флаг, определяющий, следует ли декодировать аудиоданные. Если `False`, возвращает базовый словарь в формате `{"path": audio_path, "bytes": audio_bytes}`.

stream_index (`int`, *optional*) : Индекс потока, используемый из файла. Если `None`, по умолчанию используется «лучший» индекс.

Аудио `Feature` для извлечения аудиоданных из аудиофайла.

Вход: Функция Audio принимает на вход:
- Строка `str`: абсолютный путь к аудиофайлу (т. е. допускается случайный доступ).
- `pathlib.Path`: путь к аудиофайлу (т. е. допускается случайный доступ).
- Словарь `dict` с ключами:

  - `path`: строка с относительным путём к аудиофайлу внутри архива.
  - `bytes`: Байтовое содержимое аудиофайла.

  Это полезно для файлов parquet или webdataset, в которые встроены аудиофайлы.

- Словарь `dict` с ключами:

  - `array`: Массив, содержащий аудиовыборку
  - `sampling_rate`: целое число, соответствующее частоте дискретизации аудиозаписи.

- Объект декодера аудио torchcodec: `torchcodec.decoders.AudioDecoder`.

Вывод: данные аудиопризнаков выводятся в виде объектов `torchcodec.decoders.AudioDecoder` с дополнительными ключами:

- `array`: Массив, содержащий аудиовыборку
- `sampling_rate`: целое число, соответствующее частоте дискретизации аудиозаписи.

Пример:

```py
>>> from datasets import load_dataset, Audio
>>> ds = load_dataset("PolyAI/minds14", name="en-US", split="train")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=44100, num_channels=2))
>>> ds[0]["audio"]
<datasets.features._torchcodec.AudioDecoder object at 0x11642b6a0>
>>> audio = ds[0]["audio"]
>>> audio.get_samples_played_in_range(0, 10)
AudioSamples:
    data (shape): torch.Size([2, 110592])
    pts_seconds: 0.0
    duration_seconds: 2.507755102040816
    sample_rate: 44100
```

#### cast_storage[[datasets.Audio.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L237)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в типе хранения Audio arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`

Преобразование массива Arrow в тип хранения Audio arrow. Типы Arrow, которые можно преобразовать в тип хранения Audio pyarrow:

- `pa.string()` — должен содержать данные "path"
- `pa.binary()` — должен содержать байты аудио
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен

#### decode_example[[datasets.Audio.decode_example]]

```python
decode_example(value: dict, token_per_repo_id: typing.Optional[dict[str, typing.Union[str, bool, NoneType]]] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L164)

**Параметры:**

value (`dict`) : Словарь с ключами:  - `path`: Строка с относительным путём к аудиофайлу. - `bytes`: Байты аудиофайла.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к аудиофайлам из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`)

**Возвращает:**

`torchcodec.decoders.AudioDecoder`

Декодирование примера аудиофайла в аудиоданные.

#### embed_storage[[datasets.Audio.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L283)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив. Например, файлы с путями, начинающимися с hf:// или https://

**Возвращает:** `pa.StructArray`

Массив в типе хранения Audio arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Встраивайте аудиофайлы в массив Arrow.

#### encode_example[[datasets.Audio.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L96)

**Параметры:**

value (`str`, `bytes`,`bytearray`,`dict`, `AudioDecoder`) : Данные, передаваемые на вход функции Audio.

**Возвращает:** `dict`

Кодирует пример в формат Arrow.

#### flatten[[datasets.Audio.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/audio.py#L226)

Если состояние декодируемое, вызовите ошибку, иначе разложите признаки в словарь.

### Изображение[[datasets.Image]]

#### datasets.Image[[datasets.Image]]

```python
datasets.Image(mode: typing.Optional[str] = None, decode: bool = True, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L47)

**Параметры:**

mode (`str`, *необязательный*) : Режим, в который следует преобразовать изображение. Если `None`, используется исходный режим изображения.

decode (`bool`, по умолчанию `True`) : Нужно ли декодировать данные изображения. Если `False`, возвращает базовый словарь в формате `{"path": image_path, "bytes": image_bytes}`.

Изображение `Feature` для чтения данных изображения из файла изображения.

Вход: Функция Image принимает на вход:
- Строка `str`: Абсолютный путь к файлу изображения (т. е. допускается случайный доступ).
- `pathlib.Path`: путь к файлу изображения (т.е. допускается случайный доступ).
- Словарь `dict` с ключами:

  - `path`: строка с относительным путём к файлу изображения в архиве.
  - `bytes`: Байты файла изображения.

  Это полезно для файлов parquet или webdataset, в которые встроены файлы изображений.

- Массив `np.ndarray`: массив NumPy, представляющий изображение.
- Объект изображения PIL: `PIL.Image.Image`.

Вывод: данные признаков изображения выводятся в виде объектов `PIL.Image.Image`.

Примеры:

```py
>>> from datasets import load_dataset, Image
>>> ds = load_dataset("AI-Lab-Makerere/beans", split="train")
>>> ds.features["image"]
Image(decode=True, id=None)
>>> ds[0]["image"]
<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=500x500 at 0x15E52E7F0>
>>> ds = ds.cast_column('image', Image(decode=False))
{'bytes': None,
 'path': '/root/.cache/huggingface/datasets/downloads/extracted/b0a21163f78769a2cf11f58dfc767fb458fc7cea5c05dccc0144a2c0f0bc1292/train/healthy/healthy_train.85.jpg'}
```

#### cast_storage[[datasets.Image.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L216)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в типе хранения Image arrow, то есть `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Преобразование Arrow-массива в тип хранения Image для arrow. Типы Arrow, которые можно преобразовать в тип хранения Image для pyarrow:

- `pa.string()` — должен содержать данные "path"
- `pa.large_string()` — должно содержать данные «path» (будет приведено к строке, если возможно)
- `pa.binary()` — должен содержать байты изображения
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен
- `pa.list(*)` — должен содержать данные массива изображений

#### decode_example[[datasets.Image.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L139)

**Параметры:**

value (`str` или `dict`) : строка с абсолютным путём к файлу изображения или словарь с ключами:  - `path`: строка с абсолютным или относительным путём к файлу изображения. - `bytes`: байты файла изображения.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к файлам изображений из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`).

**Возвращает:**

`PIL.Image.Image`

Декодирование примера файла изображения в данные изображения.

#### embed_storage[[datasets.Image.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L278)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив. Например, файлы с путями, начинающимися с hf:// или https://

**Возвращает:** `pa.StructArray`

Массив в типе хранения Image arrow, то есть `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Встраивайте файлы изображений в массив Arrow.

#### encode_example[[datasets.Image.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L98)

**Параметры:**

value (`str`, `np.ndarray`, `PIL.Image.Image` или `dict`) : Данные, передаваемые на вход функции Image feature.

**Возвращает:**

`dict` с полями "path" и "bytes"

Кодирует пример в формат Arrow.

#### flatten[[datasets.Image.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/image.py#L203)

Если объект находится в декодируемом состоянии, верните саму характеристику, иначе разложите её в словарь.

### Видео[[datasets.Video]]

#### datasets.Video[[datasets.Video]]

```python
datasets.Video(decode: bool = True, stream_index: typing.Optional[int] = None, dimension_order: typing.Literal['NCHW', 'NHWC'] = 'NCHW', num_ffmpeg_threads: int = 1, device: typing.Union[str, ForwardRef('torch.device'), NoneType] = 'cpu', seek_mode: typing.Literal['exact', 'approximate'] = 'exact', id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L29)

**Параметры:**

decode (`bool`, по умолчанию `True`) : Флаг, определяющий, следует ли декодировать данные видео. Если `False`, возвращает базовый словарь в формате `{"path": video_path, "bytes": video_bytes}`.

stream_index (`int`, *optional*) : Индекс потока, используемый из файла. Если `None`, по умолчанию используется «лучший» индекс.

dimension_order (`str`, по умолчанию `NCHW`) : Порядок размерностей декодированных кадров, где N — размер батча, C — количество каналов, H — высота, а W — ширина кадров.

num_ffmpeg_threads (`int`, по умолчанию `1`) : Количество потоков, используемых для декодирования видео. (Рекомендуется оставить значение равным 1)

device (`str` или `torch.device`, по умолчанию `cpu`) : Устройство, используемое для декодирования видео.

seek_mode (`str`, по умолчанию `exact`) : Определяет, будет ли доступ к кадрам «точным» (exact) или «приблизительным» (approximate). Точный режим гарантирует, что запрос кадра i всегда вернёт кадр i, но для этого требуется начальное сканирование файла. Приблизительный режим работает быстрее, так как не сканирует файл, но менее точен, поскольку использует метаданные файла для расчёта вероятного расположения кадра i. Подробнее — [здесь](https://docs.pytorch.org/torchcodec/stable/generated_examples/approximate_mode.html#sphx-glr-generated-examples-approximate-mode-py)

Видео `Feature` для чтения видеоданных из видеофайла.

Вход: Функция Video принимает на вход:
- Строка `str`: абсолютный путь к файлу видео (т. е. допускается случайный доступ).
- `pathlib.Path`: путь к файлу видео (т.е. допускается случайный доступ).
- Словарь `dict` с ключами:

  - `path`: строка с относительным путём к файлу видео в репозитории датасета.
  - `bytes`: Байты видеофайла.

  Это полезно для файлов parquet или webdataset, в которые встроены файлы видео.

- Объект декодера видео torchcodec: `torchcodec.decoders.VideoDecoder`.

Вывод: функция Video features возвращает данные в виде объектов `torchcodec.decoders.VideoDecoder`.

Примеры:

```py
>>> from datasets import Dataset, Video
>>> ds = Dataset.from_dict({"video":["path/to/Screen Recording.mov"]}).cast_column("video", Video())
>>> ds.features["video"]
Video(decode=True, id=None)
>>> ds[0]["video"]
<torchcodec.decoders._video_decoder.VideoDecoder object at 0x14a61e080>
>>> video = ds[0]["video"]
>>> video.get_frames_in_range(0, 10)
FrameBatch:
data (shape): torch.Size([10, 3, 50, 66])
pts_seconds: tensor([0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333, 0.4333,
        0.4333], dtype=torch.float64)
duration_seconds: tensor([0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167, 0.0167,
        0.0167], dtype=torch.float64)
>>> ds.cast_column('video', Video(decode=False))[0]["video]
{'bytes': None,
 'path': 'path/to/Screen Recording.mov'}
```

#### cast_storage[[datasets.Video.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L242)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в формате хранения Video arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Преобразование массива Arrow в тип хранения Video arrow. Типы Arrow, которые можно преобразовать в тип хранения Video pyarrow:

- `pa.string()` — должен содержать данные "path"
- `pa.binary()` — должен содержать байты видео
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен
- `pa.list(*)` — должен содержать данные массива видео

#### decode_example[[datasets.Video.decode_example]]

```python
decode_example(value: typing.Union[str, datasets.features.video.Example], token_per_repo_id: typing.Optional[dict[str, typing.Union[bool, str]]] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L153)

**Параметры:**

value (`str` или `dict`) : строка с абсолютным путём к файлу видео или словарь с ключами:  - `path`: строка с абсолютным или относительным путём к файлу видео. - `bytes`: байты файла видео.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к файлам видео из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`).

**Возвращает:**

`torchcodec.decoders.VideoDecoder`

Декодирование примера видеофайла в видеоданные.

#### embed_storage[[datasets.Video.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L294)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив. Например, файлы с путями, начинающимися с hf:// или https://

**Возвращает:** `pa.StructArray`

Массив в формате хранения Video arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Встраивайте файлы изображений в массив Arrow.

#### encode_example[[datasets.Video.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L105)

**Параметры:**

value (`str`, `np.ndarray`, `bytes`, `bytearray`, `VideoDecoder` или `dict`) : Данные, передаваемые на вход функции Video.

**Возвращает:**

`dict` с полями "path" и "bytes"

Кодирует пример в формат Arrow.

#### flatten[[datasets.Video.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/video.py#L229)

Если объект находится в декодируемом состоянии, верните саму характеристику, иначе разложите её в словарь.

### Mesh[[datasets.Mesh]]

#### datasets.Mesh[[datasets.Mesh]]

```python
datasets.Mesh(decode: bool = True, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L23)

**Параметры:**

decode (`bool`, по умолчанию `True`) : Флаг, определяющий, следует ли декодировать данные меша. Если `False`, возвращает базовый словарь в формате `{"path": mesh_path, "bytes": mesh_bytes}`. Декодирование меша использует `trimesh` и поддерживает файлы `.glb`, `.gltf`, `.ply` и `.stl`.

Mesh `Feature` для чтения данных 3D-сетки из файла.

Вход: функция Mesh принимает на вход:
- Строка `str`: Абсолютный путь к файлу меша (то есть допускается случайный доступ).
- `pathlib.Path`: путь к файлу меша (то есть допускается случайный доступ).
- Словарь `dict` с ключами:

  - `path`: строка с относительным путём к файлу меша внутри архива.
  - `bytes`: Байты файла меша.

  Это полезно для файлов parquet или webdataset, в которые встроены файлы сеток.

- Объект `trimesh.Trimesh` или `trimesh.Scene`: 3D-сетка или сцена.

Вывод: Функция Mesh выводит данные в виде объектов `trimesh.Trimesh` или `trimesh.Scene`.

#### cast_storage[[datasets.Mesh.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L162)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в формате хранения Mesh arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Преобразование массива Arrow в тип хранения Mesh arrow. Типы Arrow, которые можно преобразовать в тип хранения Mesh pyarrow:

- `pa.string()` — должен содержать данные "path"
- `pa.large_string()` — должно содержать данные «path» (будет приведено к строке, если возможно)
- `pa.binary()` — должен содержать байты меша
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен

#### decode_example[[datasets.Mesh.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L91)

**Параметры:**

value (`dict`) : Словарь с ключами:  - `path`: Строка с абсолютным или относительным путём к файлу меша. - `bytes`: Байты файла меша.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к файлам сетки из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`).

**Возвращает:**

`trimesh.Trimesh` или `trimesh.Scene`

Пример декодирования файла сетки.

#### embed_storage[[datasets.Mesh.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L215)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив.

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив.

**Возвращает:** `pa.StructArray`

Массив в формате хранения Mesh arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Встраивайте файлы мешей в массив Arrow.

#### encode_example[[datasets.Mesh.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L57)

**Параметры:**

value (`str`, `bytes`, `dict`, `trimesh.Trimesh` или `trimesh.Scene`) : данные, передаваемые на вход функции Mesh.

**Возвращает:**

`dict` с полями "path" и "bytes"

Кодирует пример в формат Arrow.

#### flatten[[datasets.Mesh.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/mesh.py#L149)

Если объект находится в декодируемом состоянии, верните саму характеристику, иначе разложите её в словарь.

### Json[[datasets.Json]]

#### datasets.Json[[datasets.Json]]

```python
datasets.Json(decode: bool = True, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1258)

Тип функции для объектов JSON.

Под капотом объекты хранятся в виде строк, закодированных в формате JSON.

Пример:

```py
>>> from datasets import Features, Json
>>> features = Features({'json': Json()})
>>> features
{'json': Json()}
```

```py
>>> from datasets import Dataset, Features, Json, List
>>> features = Features({"a": List(Json())})
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, features=features)
>>> # OR
>>> ds = Dataset.from_dict({"a": [[{"b": 0}, {"c": 0}]]}, on_mixed_types="use_json")
>>> ds.features
{'a': List(Json())}
>>> ds[0]
{'a': [{'b': 0}, {'c': 0}]}
>>> def f(x):
...     for y in x["a"]:
...         y["d"] = "foo"
...     return x
>>> ds = ds.map(f)
>>> ds.features
>>> ds[0]
{'a': [{'b': 0, 'd': 'foo'}, {'c': 0, 'd': 'foo'}]}
```

#### cast_storage[[datasets.Json.cast_storage]]

```python
cast_storage(storage: Array)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/features.py#L1321)

**Параметры:**

storage (`Union[pa.StringArray, pa.IntegerArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.JsonArray`

Массив в типе хранения arrow `Json`.

Преобразовать массив Arrow в тип хранения Arrow `Json`.

### Pdf[[datasets.Pdf]]

#### datasets.Pdf[[datasets.Pdf]]

```python
datasets.Pdf(decode: bool = True, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L31)

**Параметры:**

decode (`bool`, по умолчанию `True`) : Флаг, определяющий, следует ли декодировать данные PDF. Если `False`, возвращает базовый словарь в формате `{"path": pdf_path, "bytes": pdf_bytes}`.

**Экспериментально.** Функция `Feature` для чтения PDF-документов из PDF-файла.

Вход: Функция Pdf принимает на вход:
- Строка `str`: абсолютный путь к файлу PDF (т. е. допускается случайный доступ).
- `pathlib.Path`: путь к файлу PDF (то есть допускается случайный доступ).
- Словарь `dict` с ключами:
  - `path`: строка с относительным путём к файлу PDF в репозитории датасета.
  - `bytes`: Байты файла PDF. Это полезно для архивных файлов с последовательным доступом.

- Объект `pdfplumber.pdf.PDF`: объект PDF из pdfplumber.

Примеры:

```py
>>> from datasets import Dataset, Pdf
>>> ds = Dataset.from_dict({"pdf": ["path/to/pdf/file.pdf"]}).cast_column("pdf", Pdf())
>>> ds.features["pdf"]
Pdf(decode=True, id=None)
>>> ds[0]["pdf"]
<pdfplumber.pdf.PDF object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("pdf", Pdf(decode=False))
>>> ds[0]["pdf"]
{'bytes': None,
'path': 'path/to/pdf/file.pdf'}
```

#### cast_storage[[datasets.Pdf.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.ListArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L183)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в типе хранения Pdf arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Преобразование массива Arrow в тип хранения Pdf arrow. Типы Arrow, которые можно преобразовать в тип хранения Pdf pyarrow:

- `pa.string()` — должен содержать данные "path"
- `pa.binary()` — должен содержать байты изображения
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен
- `pa.list(*)` — должен содержать данные массива PDF

#### decode_example[[datasets.Pdf.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L113)

**Параметры:**

value (`str` или `dict`) : строка с абсолютным путём к файлу PDF или словарь с ключами:  - `path`: строка с абсолютным или относительным путём к файлу PDF. - `bytes`: байты файла PDF.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к файлам pdf из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`).

**Возвращает:**

`pdfplumber.pdf.PDF`

Декодирование примера файла pdf в данные pdf.

#### embed_storage[[datasets.Pdf.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L220)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив. Например, файлы с путями, начинающимися с hf:// или https://

**Возвращает:** `pa.StructArray`

Массив в типе хранения PDF arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Встраивание файлов PDF в массив Arrow.

#### encode_example[[datasets.Pdf.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L78)

**Параметры:**

value (`str`, `bytes`, `pdfplumber.pdf.PDF` или `dict`) : Данные, передаваемые на вход в функцию Pdf.

**Возвращает:**

`dict` с полями "path" и "bytes"

Кодирует пример в формат Arrow.

#### flatten[[datasets.Pdf.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/pdf.py#L170)

Если объект находится в декодируемом состоянии, верните саму характеристику, иначе разложите её в словарь.

### Nifti[[datasets.Nifti]]

#### datasets.Nifti[[datasets.Nifti]]

```python
datasets.Nifti(decode: bool = True, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L64)

**Параметры:**

decode (`bool`, по умолчанию `True`) : Нужно ли декодировать данные NIfTI. Если `False`, возвращается строка с байтами. `decode=False` не поддерживается при декодировании примеров.

**Экспериментально.** Nifti `Feature` для чтения файлов нейровизуализации в формате NIfTI.

Вход: Функция Nifti принимает на вход:
- Строка `str`: Абсолютный путь к файлу NIfTI (то есть допускается случайный доступ).
- `pathlib.Path`: путь к файлу NIfTI (то есть допускается случайный доступ).
- Словарь `dict` с ключами:
  - `path`: строка с относительным путём к файлу NIfTI в репозитории набора данных.
  - `bytes`: Байты файла NIfTI. Это полезно для архивных файлов с последовательным доступом.

- Объект изображения `nibabel` (например, `nibabel.nifti1.Nifti1Image`).

Примеры:

```py
>>> from datasets import Dataset, Nifti
>>> ds = Dataset.from_dict({"nifti": ["path/to/file.nii.gz"]}).cast_column("nifti", Nifti())
>>> ds.features["nifti"]
Nifti(decode=True, id=None)
>>> ds[0]["nifti"]
<nibabel.nifti1.Nifti1Image object at 0x7f8a1c2d8f40>
>>> ds = ds.cast_column("nifti", Nifti(decode=False))
>>> ds[0]["nifti"]
{'bytes': None,
'path': 'path/to/file.nii.gz'}
```

#### cast_storage[[datasets.Nifti.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray, pyarrow.lib.BinaryArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L298)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray, pa.BinaryArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в типе хранения Nifti arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Преобразование массива Arrow в тип хранения Nifti arrow. Типы Arrow, которые можно преобразовать в тип хранения Nifti pyarrow:

- `pa.string()` — должен содержать данные "path"
- `pa.binary()` — должен содержать байты NIfTI
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен

#### decode_example[[datasets.Nifti.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L150)

**Параметры:**

value (`str` или `dict`) : строка с абсолютным путём к файлу NIfTI, словарь с ключами:  - `path`: строка с абсолютным или относительным путём к файлу NIfTI. - `bytes`: байты файла NIfTI.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к файлам NIfTI из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`).

**Возвращает:**

объекты `nibabel.Nifti1Image`

Декодирование примера файла NIfTI в объект изображения nibabel.

#### embed_storage[[datasets.Nifti.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L216)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив. Например, файлы с путями, начинающимися с hf:// или https://

**Возвращает:** `pa.StructArray`

Массив в типе хранения NifTI arrow, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Встраивание файлов NifTI в массив Arrow.

#### encode_example[[datasets.Nifti.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L110)

**Параметры:**

value (`str`, `bytes`, `nibabel.Nifti1Image` или `dict`) : Данные, передаваемые на вход в Nifti feature.

**Возвращает:**

`dict` с полями "path" и "bytes"

Кодирует пример в формат Arrow.

#### flatten[[datasets.Nifti.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/nifti.py#L285)

Если объект находится в декодируемом состоянии, верните саму характеристику, иначе разложите её в словарь.

### BioSequence[[datasets.BioSequence]]

#### datasets.BioSequence[[datasets.BioSequence]]

```python
datasets.BioSequence(format: str = 'fasta', decode: bool = True, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L44)

**Параметры:**

format (`str`, по умолчанию `"fasta"`) : Название формата последовательности, как его понимает `Bio.SeqIO`. Типичные значения — `"fasta"`, `"fastq"` и `"genbank"`.

decode (`bool`, по умолчанию `True`) : Флаг, определяющий, следует ли декодировать данные последовательности. Если `False`, возвращает базовый словарь в формате `{"path": path, "bytes": bytes}`.

**Экспериментально.** BioSequence `Feature` для чтения записей биологических последовательностей из файла последовательностей.

Файл последовательности содержит одну или несколько записей остатков с их идентификаторами и аннотациями. FASTA, FASTQ и GenBank имеют одинаковую структуру на этом уровне и различаются только используемым парсером, поэтому `format` выбирает парсер, а не тип.

Вход: Функция BioSequence принимает на вход:
- Строка `str`: Абсолютный путь к файлу последовательности (т.е. допускается случайный доступ).
- `pathlib.Path`: путь к файлу последовательности (т.е. допускается случайный доступ).
- Словарь `dict` с ключами:
  - `path`: строка с относительным путём к файлу последовательности в репозитории набора данных.
  - `bytes`: Байты файла последовательности. Это полезно для архивных файлов с последовательным доступом.

- Объект `Bio.SeqRecord.SeqRecord`: запись последовательности biopython.

Примеры:

```py
>>> from datasets import Dataset, BioSequence
>>> ds = Dataset.from_dict({"seq": ["path/to/sequences.fasta"]}).cast_column("seq", BioSequence())
>>> ds.features["seq"]
BioSequence(format='fasta', decode=True)
>>> ds[0]["seq"]
SeqRecord(seq=Seq('ACGT'), id='seq1', name='seq1', description='seq1', dbxrefs=[])
>>> ds = ds.cast_column("seq", BioSequence(decode=False))
>>> ds[0]["seq"]
{'bytes': None,
'path': 'path/to/sequences.fasta'}
```

#### cast_storage[[datasets.BioSequence.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L199)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в типе хранения arrow BioSequence, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Преобразование массива Arrow в тип хранения BioSequence arrow. Типы Arrow, которые можно преобразовать в тип хранения BioSequence pyarrow:

- `pa.string()` — должен содержать данные "path"
- `pa.binary()` — должен содержать байты файла
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен

#### decode_example[[datasets.BioSequence.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L132)

**Параметры:**

value (`str` или `dict`) : строка с абсолютным путём к файлу или словарь с ключами:  - `path`: строка с абсолютным или относительным путём к файлу. - `bytes`: байты файла.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к файлам из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`).

**Возвращает:**

`Bio.SeqRecord.SeqRecord`

Декодировать файл с примером последовательности в запись biopython.

Файл может содержать множество записей; этот метод возвращает первую, так как одна строка соответствует одной записи. Используйте встроенные загрузчики последовательностей, чтобы развернуть файл с несколькими записями в одну строку на каждую запись.

#### embed_storage[[datasets.BioSequence.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L219)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив.

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив.

**Возвращает:** `pa.StructArray`

Массив в типе хранения arrow BioSequence.

Встраивайте файлы последовательностей в массив Arrow.

#### encode_example[[datasets.BioSequence.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L99)

**Параметры:**

value (`str`, `bytes`, `Bio.SeqRecord.SeqRecord` или `dict`) : Данные, передаваемые на вход в функцию BioSequence.

**Возвращает:**

`dict` с полями "path" и "bytes"

Кодирует пример в формат Arrow.

#### flatten[[datasets.BioSequence.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_sequence.py#L186)

Если объект находится в декодируемом состоянии, верните саму характеристику, иначе разложите её в словарь.

### BioStructure[[datasets.BioStructure]]

#### datasets.BioStructure[[datasets.BioStructure]]

```python
datasets.BioStructure(format: str = 'pdb', decode: bool = True, id: typing.Optional[str] = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L48)

**Параметры:**

format (`str`, по умолчанию `"pdb"`) : Формат структуры, `"pdb"` или `"mmcif"`.

decode (`bool`, по умолчанию `True`) : Флаг, определяющий, следует ли декодировать данные структуры. Если `False`, возвращает базовый словарь в формате `{"path": path, "bytes": bytes}`.

**Экспериментально.** BioStructure `Feature` для чтения макромолекулярных структур из файла структуры.

Файл структуры содержит трёхмерные координаты атомов молекулы, сгруппированные в цепи и остатки. Форматы PDB и mmCIF описывают одни и те же объекты и отличаются только используемым парсером, поэтому `format` выбирает парсер, а не тип.

Вход: функция BioStructure принимает на вход:
- Строка `str`: абсолютный путь к файлу структуры (то есть допускается случайный доступ).
- `pathlib.Path`: путь к файлу структуры (т.е. допускается случайный доступ).
- Словарь `dict` с ключами:
  - `path`: строка с относительным путём к файлу структуры в репозитории набора данных.
  - `bytes`: Байты файла структуры. Это полезно для архивных файлов с последовательным доступом.

- Структура `Bio.PDB.Structure.Structure`: структура biopython.

Примеры:

```py
>>> from datasets import Dataset, BioStructure
>>> ds = Dataset.from_dict({"st": ["path/to/1abc.pdb"]}).cast_column("st", BioStructure())
>>> ds.features["st"]
BioStructure(format='pdb', decode=True)
>>> ds[0]["st"]
<Structure id=1abc>
>>> ds = ds.cast_column("st", BioStructure(decode=False))
>>> ds[0]["st"]
{'bytes': None,
'path': 'path/to/1abc.pdb'}
```

#### cast_storage[[datasets.BioStructure.cast_storage]]

```python
cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L204)

**Параметры:**

storage (`Union[pa.StringArray, pa.StructArray]`) : массив PyArrow для приведения.

**Возвращает:** `pa.StructArray`

Массив в типе хранения arrow BioStructure, а именно `pa.struct({"bytes": pa.binary(), "path": pa.string()})`.

Преобразование массива Arrow в тип хранения arrow для BioStructure. Типы Arrow, которые можно преобразовать в тип хранения pyarrow для BioStructure:

- `pa.string()` — должен содержать данные "path"
- `pa.binary()` — должен содержать байты файла
- `pa.struct({"bytes": pa.binary()})`
- `pa.struct({"path": pa.string()})`
- `pa.struct({"bytes": pa.binary(), "path": pa.string()})` — порядок не важен

#### decode_example[[datasets.BioStructure.decode_example]]

```python
decode_example(value: dict, token_per_repo_id = None)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L138)

**Параметры:**

value (`str` или `dict`) : строка с абсолютным путём к файлу или словарь с ключами:  - `path`: строка с абсолютным или относительным путём к файлу. - `bytes`: байты файла.

token_per_repo_id (`dict`, *необязательный*) : Чтобы получить доступ к файлам из частных репозиториев на Hub и декодировать их, можно передать словарь repo_id (`str`) -> token (`bool` или `str`).

**Возвращает:**

`Bio.PDB.Structure.Structure`

Декодировать файл структуры примера в структуру biopython.

#### embed_storage[[datasets.BioStructure.embed_storage]]

```python
embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L224)

**Параметры:**

storage (`pa.StructArray`) : массив PyArrow для встраивания.

token_per_repo_id (`dict`, optional) : Словарь repo_id -> token для получения байтов файлов.

local_files (`bool`, по умолчанию `True`) : Встраивать ли данные локальных файлов в массив.

remote_files (`bool`, по умолчанию `True`) : Встраивать ли данные удалённых файлов в массив.

**Возвращает:** `pa.StructArray`

Массив в типе хранения arrow BioStructure.

Встраивайте файлы структуры в массив Arrow.

#### encode_example[[datasets.BioStructure.encode_example]]

```python
encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')])
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L105)

**Параметры:**

value (`str`, `bytes`, `Bio.PDB.Structure.Structure` или `dict`) : Данные, передаваемые на вход в функцию BioStructure.

**Возвращает:**

`dict` с полями "path" и "bytes"

Кодирует пример в формат Arrow.

#### flatten[[datasets.BioStructure.flatten]]

```python
flatten()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/features/bio_structure.py#L191)

Если объект находится в декодируемом состоянии, верните саму характеристику, иначе разложите её в словарь.

## Файловые системы[[datasets.filesystems.is_remote_filesystem]]

#### datasets.filesystems.is_remote_filesystem[[datasets.filesystems.is_remote_filesystem]]

```python
datasets.filesystems.is_remote_filesystem(fs: AbstractFileSystem)
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/filesystems/__init__.py#L33)

**Параметры:**

fs (`fsspec.spec.AbstractFileSystem`) : Абстрактный суперкласс для файловых систем в стиле Python, например `fsspec.filesystem('file')` или `s3fs.S3FileSystem`.

Проверяет, является ли `fs` удалённой файловой системой.

## Отпечаток[[datasets.fingerprint.Hasher]]

#### datasets.fingerprint.Hasher[[datasets.fingerprint.Hasher]]

```python
datasets.fingerprint.Hasher()
```

[Источник](https://github.com/huggingface/datasets/blob/main/src/datasets/fingerprint.py#L196)

Хэшировщик, принимающий объекты Python в качестве входных данных.

