# Principais classes ## DatasetInfo[[datasets.DatasetInfo]] #### datasets.DatasetInfo[[datasets.DatasetInfo]] ```python datasets.DatasetInfo(description: str = , citation: str = , homepage: str = , license: str = , 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L92) **Parâmetros:** description (`str`) : Uma descrição do conjunto de dados. citation (`str`) : Uma citação BibTeX do conjunto de dados. homepage (`str`) : A URL para a página inicial oficial do conjunto de dados. license (`str`) : A licença do conjunto de dados. Pode ser o nome da licença ou um parágrafo contendo os termos da licença. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Os recursos usados para especificar os tipos de colunas do conjunto de dados. post_processed (`PostProcessedInfo`, *opcional*) : Obsoleto. Informações sobre os recursos de um possível pós-processamento de um conjunto de dados. Por exemplo, pode conter as informações de um índice. supervised_keys (`SupervisedKeysData`, *opcional*) : Especifica o recurso de entrada e o rótulo para aprendizado supervisionado, se aplicável ao conjunto de dados (legado do TFDS). builder_name (`str`, *opcional*) : O nome da subclasse de `GeneratorBasedBuilder` usada para criar o conjunto de dados. Também é a versão snake_case do nome da classe do construtor do conjunto de dados. config_name (`str`, *opcional*) : O nome da configuração derivada de [BuilderConfig](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.BuilderConfig). version (`str` ou [Version](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.Version), *opcional*) : A versão do conjunto de dados. splits (`dict`, *opcional*) : O mapeamento entre o nome da divisão e os metadados. download_checksums (`dict`, *opcional*) : O mapeamento entre a URL para baixar os checksums do conjunto de dados e os metadados correspondentes. download_size (`int`, *opcional*) : O tamanho dos arquivos a serem baixados para gerar o conjunto de dados, em bytes. post_processing_size (`int`, *opcional*) : Obsoleto. Tamanho do conjunto de dados em bytes após o pós-processamento, se houver. dataset_size (`int`, *opcional*) : O tamanho combinado em bytes das tabelas Arrow para todos os splits. size_in_bytes (`int`, *opcional*) : O tamanho combinado em bytes de todos os arquivos associados ao conjunto de dados (arquivos baixados + arquivos Arrow). - ****config_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para o [BuilderConfig](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.BuilderConfig) e usados no [DatasetBuilder](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.DatasetBuilder). Informações sobre um conjunto de dados. `DatasetInfo` documenta conjuntos de dados, incluindo seu nome, versão e recursos. Consulte os argumentos do construtor e as propriedades para obter a lista completa. Nem todos os campos são conhecidos na construção e podem ser atualizados posteriormente. #### from_directory[[datasets.DatasetInfo.from_directory]] ```python from_directory(dataset_info_dir: str, storage_options: typing.Optional[dict] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L247) **Parâmetros:** dataset_info_dir (`str`) : O diretório que contém o arquivo de metadados. Este deve ser o diretório raiz de uma versão específica do conjunto de dados. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. Crie [DatasetInfo](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetInfo) a partir do arquivo JSON em `dataset_info_dir`. Esta função atualiza todos os campos gerados dinamicamente (num_examples, hash, time of creation,...) do [DatasetInfo](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetInfo). Isso sobrescreverá todos os metadados anteriores. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/info.py#L186) **Parâmetros:** dataset_info_dir (`str`) : Diretório de destino. pretty_print (`bool`, padrão `False`) : Se `True`, o JSON será formatado com nível de indentação 4. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. Escreva `DatasetInfo` e a licença (se presente) como arquivos JSON em `dataset_info_dir`. Exemplo: ```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/") ``` ## Conjunto de dados[[datasets.Dataset]] A classe base [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) implementa um Dataset baseado em uma tabela do 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L709) Um Dataset baseado em uma tabela 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6284) **Parâmetros:** name (`str`) : Nome da coluna. column (`list` ou `np.array`) : Dados da coluna a serem adicionados. feature (`FeatureType` ou `None`, padrão `None`) : Tipo de dados da coluna. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Adicionar coluna ao Dataset. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6546) **Parâmetros:** item (`dict`) : Dados do item a serem adicionados. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Adicionar item ao Dataset. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L792) **Parâmetros:** filename (`str`) : Nome do arquivo do conjunto de dados. info (`DatasetInfo`, *opcional*) : Informações do dataset, como descrição, citação, etc. split (`NamedSplit`, *opcional*) : Nome da divisão do conjunto de dados. indices_filename (`str`, *opcional*) : Nomes dos arquivos dos índices. in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Instanciar um Dataset baseado em uma tabela Arrow no arquivo 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L832) **Parâmetros:** buffer (`pyarrow.Buffer`) : buffer Arrow. info (`DatasetInfo`, *opcional*) : Informações do dataset, como descrição, citação, etc. split (`NamedSplit`, *opcional*) : Nome da divisão do conjunto de dados. indices_buffer (`pyarrow.Buffer`, *opcional*) : Buffer de índices do Arrow. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Instanciar um Dataset baseado em um buffer 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L864) **Parâmetros:** df (`pandas.DataFrame`) : Dataframe que contém o conjunto de dados. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. info (`DatasetInfo`, *opcional*) : Informações do dataset, como descrição, citação, etc. split (`NamedSplit`, *opcional*) : Nome da divisão do conjunto de dados. preserve_index (`bool`, *opcional*) : Se deve armazenar o índice como uma coluna adicional no Dataset resultante. O valor padrão de `None` armazenará o índice como uma coluna, exceto para `RangeIndex`, que é armazenado apenas como metadados. Use `preserve_index=True` para forçar que ele seja armazenado como uma coluna. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Converta `pandas.DataFrame` para `pyarrow.Table` para criar um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset). Os tipos de coluna na Tabela Arrow resultante são inferidos a partir dos dtypes das `pandas.Series` no DataFrame. No caso de Series não-object, o dtype do NumPy é traduzido para seu equivalente no Arrow. No caso de `object`, precisamos inferir o tipo de dados examinando os objetos Python presentes nesta Series. Observe que Series do dtype `object` não carregam informações suficientes para sempre levar a um tipo Arrow significativo. No caso em que não podemos inferir um tipo, por exemplo, porque o DataFrame tem comprimento 0 ou a Series contém apenas objetos `None/nan`, o tipo é definido como `null`. Esse comportamento pode ser evitado construindo features explícitas e passando-as para esta função. Importante: um dataset criado com from_pandas() fica na memória e, portanto, não possui um diretório de cache associado. Isso pode mudar no futuro, mas, por enquanto, se você quiser reduzir o uso de memória, deve gravá-lo novamente em disco e recarregá-lo usando, por exemplo, save_to_disk / load_from_disk. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L982) **Parâmetros:** mapping (`Mapping`) : Mapeamento de strings para Arrays ou listas Python. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. info (`DatasetInfo`, *opcional*) : Informações do dataset, como descrição, citação, etc. split (`NamedSplit`, *opcional*) : Nome da divisão do conjunto de dados. on_mixed_types (`Literal["use_json"]`, *opcional*, padrão `None`) : Se "use_json", use o tipo Json() para campos de tipos mistos, ou seja, campos não estruturados que contêm dados sem um esquema predefinido. Nesse caso, um campo com tipo misto é definido como Json(). Isso permite carregar listas com uma mistura de strings/inteiros/floats, por exemplo, ou dicionários com tipos de valores arbitrários. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Converta um `dict` para uma `pyarrow.Table` para criar um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset). Importante: um dataset criado com from_dict() fica na memória e, portanto, não possui um diretório de cache associado. Isso pode mudar no futuro, mas, por enquanto, se você quiser reduzir o uso de memória, deve gravá-lo novamente em disco e recarregá-lo usando, por exemplo, save_to_disk / load_from_disk. Exemplos: Obtenha um Dataset a partir de um dicionário contendo uma lista por coluna: ```py >>> ds = Dataset.from_dict({"text": ["hello there !", "general kenobi !"]}) ``` Pass features para definir os tipos de coluna, por exemplo, para um conjunto de dados de imagens: ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_dict({"image": ["path/to/image.png"]}, features=features) ``` Os datasets são baseados no Arrow, que é um formato colunar, e, portanto, esperam que cada exemplo tenha o mesmo tipo e subtipos, e que os dicionários tenham as mesmas chaves e tipos de valores. Ao carregar um dataset, ocorre um erro quando os campos têm tipos incompatíveis, e os campos ausentes nos dicionários são preenchidos com None para que todos os dicionários tenham as mesmas chaves e tipos de valores. Para evitar isso e permitir tipos mistos sem erros, você pode usar `on_mixed_types="use_json"` ou especificar `features=` com um tipo [Json](/docs/datasets/v5.2.0/pt/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"}] ``` Isso também é útil para listas de dicionários com chaves e valores arbitrários, para evitar preencher campos ausentes com 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 ``` Outro exemplo com dados de chamada de ferramentas: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1148) **Parâmetros:** mapping (`List[dict]`) : Uma lista de mapeamentos de strings para valores de linha. features (`Features`, opcional) : Recursos do conjunto de dados. info (`DatasetInfo`, opcional) : Informações do conjunto de dados, como descrição, citação, etc. split (`NamedSplit`, opcional) : Nome da divisão do conjunto de dados. on_mixed_types (`Literal["use_json"]`, *opcional*, padrão `None`) : Se "use_json", use o tipo Json() para campos de tipos mistos, ou seja, campos não estruturados que contêm dados sem um esquema predefinido. Nesse caso, um campo com tipo misto é definido como Json(). Isso permite carregar listas com uma mistura de strings/inteiros/floats, por exemplo, ou dicionários com tipos de valores arbitrários. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Converta uma lista de dicts para uma `pyarrow.Table` para criar um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset)`. Observe que as chaves da primeira entrada serão usadas para determinar as colunas do conjunto de dados, independentemente do que for passado para features. Importante: um dataset criado com from_list() fica em memória e, portanto, não possui um diretório de cache associado. Isso pode mudar no futuro, mas, por enquanto, se você quiser reduzir o uso de memória, deve gravá-lo novamente em disco e recarregá-lo usando, por exemplo, save_to_disk / load_from_disk. Exemplos: Obtenha um Dataset de uma lista contendo os exemplos: ```py >>> ds = Dataset.from_list([{"text": "hello there !"}, {"text": "general kenobi !"}]}) ``` Pass features para definir os tipos de coluna, por exemplo, para um conjunto de dados de imagens: ```py >>> features = Features({"image": Image()}) >>> ds = Dataset.from_list([{"image": "path/to/image.png"}], features=features) ``` Os datasets são baseados no Arrow, que é um formato colunar, e, portanto, esperam que cada exemplo tenha o mesmo tipo e subtipos, e que os dicionários tenham as mesmas chaves e tipos de valores. Ao carregar um dataset, ocorre um erro quando os campos têm tipos incompatíveis, e os campos ausentes nos dicionários são preenchidos com None para que todos os dicionários tenham as mesmas chaves e tipos de valores. Para evitar isso e permitir tipos mistos sem erros, você pode usar `on_mixed_types="use_json"` ou especificar `features=` com um tipo [Json](/docs/datasets/v5.2.0/pt/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"}] ``` Isso também é útil para listas de dicionários com chaves e valores arbitrários, para evitar preencher campos ausentes com 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 ``` Outro exemplo com dados de chamada de ferramentas: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1337) **Parâmetros:** generator ( --`Callable`): Uma função geradora que `yields` exemplos. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. gen_kwargs(`dict`, *opcional*) : Argumentos de palavra-chave a serem passados para o chamável `generator`. Você pode definir um conjunto de dados particionado passando a lista de partições em `gen_kwargs` e definindo `num_proc` maior que 1. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao baixar e gerar o dataset localmente. Isso é útil se o dataset for composto por múltiplos arquivos. O multiprocessing é desabilitado por padrão. Se `num_proc` for maior que um, todos os valores de lista em `gen_kwargs` devem ter o mesmo comprimento. Esses valores serão divididos entre as chamadas ao gerador. O número de shards será o mínimo entre a lista mais curta em `gen_kwargs` e `num_proc`. split ([NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit), padrão `Split.TRAIN`) : Nome da divisão a ser atribuído ao conjunto de dados. fingerprint (`str`, *opcional*) : Impressão digital que será usada para gerar o ID do conjunto de dados. Por padrão, `fingerprint` é gerada por meio de hash da função geradora e de todos os argumentos, o que pode ser lento se usar objetos grandes, como modelos de IA. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para :`GeneratorConfig`. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Crie um Dataset a partir de um gerador. Carregue os dados do gerador, cacheie os dados em formato Arrow no disco e retorne o Dataset dos dados Arrow mapeados na memória no disco. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2110) A tabela Apache Arrow que sustenta o conjunto de dados. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2130) Os arquivos de cache contendo a tabela Apache Arrow que sustenta o conjunto de dados. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2148) Número de colunas no conjunto de dados. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2163) Número de linhas no conjunto de dados (igual a [Dataset.__len__()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.__len__)). Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2180) Nomes das colunas no conjunto de dados. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2195) Formato do conjunto de dados (número de colunas, número de linhas). Exemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.shape (1066, 2) ``` #### único[[datasets.Dataset.unique]] ```python unique(column: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2212) **Parâmetros:** column (`str`) : Nome da coluna (liste todos os nomes de colunas com [column_names](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.column_names)). **Retorna:** `list` Lista de elementos únicos na coluna fornecida. Retorna uma lista dos elementos únicos em uma coluna. Isso é implementado no backend de baixo nível e, portanto, é muito rápido. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2318) **Parâmetros:** new_fingerprint (`str`, *opcional*) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Uma cópia do conjunto de dados com colunas achatadas. Achatar a tabela. Cada coluna com tipo struct é achatada em uma coluna por campo do struct. As outras colunas permanecem inalteradas. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2365) **Parâmetros:** features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features)) : Novos recursos para os quais o conjunto de dados será convertido. Os nomes dos campos nos recursos devem corresponder aos nomes atuais das colunas. O tipo dos dados também deve ser convertível de um tipo para o outro. Para conversões não triviais, por exemplo, `str` <-> `ClassLabel`, você deve usar [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.map) para atualizar o Dataset. batch_size (`int`, padrão `1000`) : Número de exemplos por lote fornecidos ao cast. Se `batch_size <= 0` ou `batch_size == None`, forneça o conjunto de dados completo como um único lote para o cast. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. load_from_cache_file (`bool`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena o cálculo atual de `function` puder ser identificado, use-o em vez de recalcular. cache_file_name (`str`, *opcional*, padrão `None`) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar os resultados do cálculo em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.map). num_proc (`int`, *opcional*, padrão `None`) : Número de processos para multiprocessamento. Por padrão, não utiliza multiprocessamento. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Uma cópia do conjunto de dados com recursos convertidos. Convert o conjunto de dados para um novo conjunto de recursos. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2449) **Parâmetros:** column (`str`) : Nome da coluna. feature (`FeatureType`) : Recurso de destino. new_fingerprint (`str`, *opcional*) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Convert a coluna para recurso para decodificação. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2492) **Parâmetros:** column_names (`Union[str, List[str]]`) : Nome da(s) coluna(s) a ser(em) removida(s). new_fingerprint (`str`, *opcional*) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Uma cópia do objeto de dataset sem as colunas a serem removidas. Remove uma ou várias colunas do conjunto de dados e os recursos associados a elas. Você também pode remover uma coluna usando [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.map) com `remove_columns`, mas o método presente não copia os dados das colunas restantes e, portanto, é mais rápido. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2547) **Parâmetros:** original_column_name (`str`) : Nome da coluna a ser renomeada. new_column_name (`str`) : Novo nome para a coluna. new_fingerprint (`str`, *opcional*) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Uma cópia do conjunto de dados com uma coluna renomeada. Renomeie uma coluna no dataset e mova os recursos associados à coluna original para o novo nome da coluna. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2613) **Parâmetros:** column_mapping (`Dict[str, str]`) : Um mapeamento de colunas para renomear para seus novos nomes new_fingerprint (`str`, *opcional*) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Uma cópia do conjunto de dados com colunas renomeadas Renomeie várias colunas no conjunto de dados e mova os recursos associados às colunas originais para os novos nomes de coluna. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2680) **Parâmetros:** column_names (`Union[str, List[str]]`) : Nome da(s) coluna(s) a ser(em) mantida(s). new_fingerprint (`str`, *opcional*) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Uma cópia do objeto de conjunto de dados que consiste apenas nas colunas selecionadas. Selecione uma ou várias colunas no conjunto de dados e os recursos associados a elas. Exemplo: ```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 }) ``` #### class_encode_column[[datasets.Dataset.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2243) **Parâmetros:** column (`str`) : O nome da coluna para converter (liste todos os nomes de colunas com [column_names](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.column_names)) include_nulls (`bool`, padrão `False`) : Se deve incluir valores nulos nos rótulos de classe. Se `True`, os valores nulos serão codificados como o rótulo de classe `"None"`. Converte a coluna indicada em [ClassLabel](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.ClassLabel) e atualiza a tabela. Exemplo: ```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__() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2736) Número de linhas no conjunto de dados. Exemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="validation") >>> ds.__len__ ``` #### __iter__[[datasets.Dataset.__iter__]] ```python __iter__() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2753) Itere pelos exemplos. Se um formato for definido com [Dataset.set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format), as linhas serão retornadas no formato selecionado. #### iter[[datasets.Dataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2782) **Parâmetros:** batch_size (`int`) : tamanho de cada lote a ser gerado. drop_last_batch (`bool`, padrão *False*) : Se um último lote menor que o batch_size deve ser descartado Itere pelos lotes de tamanho *batch_size*. Se um formato for definido com [*~datasets.Dataset.set_format*], as linhas serão retornadas no formato selecionado. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2826) **Parâmetros:** type (`str`, *opcional*) : Tipo de saída selecionado em `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__`` retorna objetos python (padrão). columns (`List[str]`, *opcional*) : Colunas a serem formatadas na saída. `None` significa que `__getitem__` retorna todas as colunas (padrão). output_all_columns (`bool`, padrão `False`) : Mantém também as colunas não formatadas na saída (como objetos Python). - ****format_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave passados para a função de conversão, como `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Para ser usado em uma declaração `with`. Define o formato de retorno de `__getitem__` (tipo e colunas). #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2858) **Parâmetros:** type (`str`, *opcional*) : Tipo de saída selecionado em `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` retorna objetos python (padrão). columns (`List[str]`, *opcional*) : Colunas a serem formatadas na saída. `None` significa que `__getitem__` retorna todas as colunas (padrão). output_all_columns (`bool`, padrão `False`) : Mantém também as colunas não formatadas na saída (como objetos Python). - ****format_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave passados para a função de conversão, como `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Defina o formato de retorno de `__getitem__` (tipo e colunas). O formatação dos dados é aplicada em tempo real. O formato `type` (por exemplo, "numpy") é usado para formatar lotes ao usar `__getitem__`. Também é possível usar transformações personalizadas para formatação usando [set_transform()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_transform). É possível chamar [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.map) depois de chamar `set_format`. Como `map` pode adicionar novas colunas, a lista de colunas formatadas é atualizado. Nesse caso, se você aplicar `map` em um conjunto de dados para adicionar uma nova coluna, essa coluna será formatada da seguinte forma: ``` new formatted columns = (all columns - previously unformatted columns) ``` Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2966) **Parâmetros:** transform (`Callable`, *opcional*) : Transformação de formatação definida pelo usuário, substitui o formato definido por [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format). Uma função de formatação é um chamável que recebe um lote (como um `dict`) como entrada e retorna um lote. Esta função é aplicada imediatamente antes de retornar os objetos em `__getitem__`. columns (`List[str]`, *opcional*) : Colunas a serem formatadas na saída. Se especificado, o lote de entrada da transformação contém apenas essas colunas. output_all_columns (`bool`, padrão `False`) : Manter também as colunas não formatadas na saída (como objetos Python). Se definido como True, as outras colunas não formatadas são mantidas junto com a saída da transformação. Defina o formato de retorno de `__getitem__` usando esta transformação. A transformação é aplicada em tempo real nos lotes quando `__getitem__` é chamado. Assim como [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format), isso pode ser redefinido usando [reset_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.reset_format). Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L2937) Redefina o formato de retorno de `__getitem__` para objetos Python e todas as colunas. Igual a `self.set_format()` Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3009) **Parâmetros:** type (`str`, *opcional*) : Tipo de saída selecionado em `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` retorna objetos python (padrão). columns (`List[str]`, *opcional*) : Colunas a serem formatadas na saída. `None` significa que `__getitem__` retorna todas as colunas (padrão). output_all_columns (`bool`, padrão `False`) : Mantém também as colunas não formatadas na saída (como objetos Python). - ****format_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave passados para a função de conversão, como `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Defina o formato de retorno de `__getitem__` (tipo e colunas). O formatação dos dados é aplicada em tempo real. O formato `type` (por exemplo, "numpy") é usado para formatar lotes ao usar `__getitem__`. Também é possível usar transforms personalizados para formatação usando [with_transform()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.with_transform). Ao contrário de [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format), `with_format` retorna um novo objeto [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3080) **Parâmetros:** transform (`Callable`, `optional`) : Transformação de formatação definida pelo usuário, substitui o formato definido por [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format). Uma função de formatação é um objeto chamável que recebe um lote (como um `dict`) como entrada e retorna um lote. Esta função é aplicada imediatamente antes de retornar os objetos em `__getitem__`. columns (`List[str]`, `optional`) : Colunas a serem formatadas na saída. Se especificado, o lote de entrada da transformação contém apenas essas colunas. output_all_columns (`bool`, padrão `False`) : Manter também as colunas não formatadas na saída (como objetos Python). Se definido como `True`, as outras colunas não formatadas são mantidas junto com a saída da transformação. Defina o formato de retorno de `__getitem__` usando esta transformação. A transformação é aplicada em tempo real nos lotes quando `__getitem__` é chamado. Assim como [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format), isso pode ser redefinido usando [reset_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.reset_format). Ao contrário de [set_transform()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_transform), `with_transform` retorna um novo objeto [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3156) Pode ser usado para indexar colunas (por nomes de string) ou linhas (por índice inteiro ou iterável de índices ou bools). #### cleanup_cache_files[[datasets.Dataset.cleanup_cache_files]] ```python cleanup_cache_files() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3169) **Retorna:** `int` Número de arquivos removidos. Limpe todos os arquivos de cache no diretório de cache do dataset, exceto o arquivo de cache atualmente em uso, se houver um. Tenha cuidado ao executar este comando para garantir que nenhum outro processo esteja usando outros arquivos de cache no momento. Exemplo: ```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') ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L3216) **Parâmetros:** function (`Callable`) : Função com uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` se `batched=False` e `with_indices=False` e `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> Dict[str, Any]` se `batched=False` e `with_indices=True` e/ou `with_rank=True` (um argumento extra para cada) - `function(batch: Dict[str, List]) -> Dict[str, List]` se `batched=True` e `with_indices=False` e `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> Dict[str, List]` se `batched=True` e `with_indices=True` e/ou `with_rank=True` (um argumento extra para cada) Para uso avançado, a função também pode retornar um `pyarrow.Table`. Se a função for assíncrona, o `map` executará sua função em paralelo. Além disso, se sua função não retornar nada (`None`), o `map` executará sua função e retornará o dataset inalterado. Se nenhuma função for fornecida, usa-se a função identidade por padrão: `lambda x: x`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, neste caso, a assinatura de `function` deve ser `def function(example, idx[, rank]): ...`. with_rank (`bool`, padrão `False`) : Fornece o rank do processo para `function`. Observe que, nesse caso, a assinatura de `function` deve ser `def function(example[, idx], rank): ...`. input_columns (`Optional[Union[str, List[str]]]`, padrão `None`) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um `dict` mapeando todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para a `function`. batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched=True`. Se `batch_size <= 0` ou `batch_size == None`, forneça o conjunto de dados completo como um único lote para `function`. drop_last_batch (`bool`, padrão `False`) : Se um último lote menor que o batch_size deve ser descartado em vez de ser processado pela função. remove_columns (`Optional[Union[str, List[str]]]`, padrão `None`) : Remove uma seleção de colunas durante o mapeamento. As colunas serão removidas antes de atualizar os exemplos com a saída de `function`, ou seja, se `function` estiver adicionando colunas com nomes em `remove_columns`, essas colunas serão mantidas. keep_in_memory (`bool`, padrão `False`) : Mantém o conjunto de dados em memória em vez de gravá-lo em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena o cálculo atual de `function` puder ser identificado, use-o em vez de recalcular. cache_file_name (`str`, *opcional*, padrão `None`) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar os resultados do cálculo em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. features (`Optional[datasets.Features]`, padrão `None`) : Use um Features específico para armazenar o arquivo de cache em vez do gerado automaticamente. disable_nullable (`bool`, padrão `False`) : Não permite valores nulos na tabela. fn_kwargs (`Dict`, *opcional*, padrão `None`) : Argumentos de palavra-chave a serem passados para `function`. num_proc (`int`, *opcional*, padrão `None`) : O número de processos a serem usados para multiprocessamento. - Se `None` ou `0`, nenhum multiprocessamento é usado e a operação é executada no processo principal. - Se for maior que `1`, um ou vários processos de trabalho são usados para processar dados em paralelo. Observação: a função passada para `map()` deve ser serializável (picklable) para que o multiprocessamento funcione corretamente (ou seja, prefira funções definidas no nível superior de um módulo, não dentro de outra função ou classe). suffix_template (`str`): Se `cache_file_name` for especificado, este sufixo será adicionado ao final do nome base de cada arquivo. Padrão: `"_{rank:05d}_of_{num_proc:05d}"`. Por exemplo, se `cache_file_name` for "processed.arrow", então para `rank=1` e `num_proc=4`, o arquivo resultante seria `"processed_00001_of_00004.arrow"` para o sufixo padrão. new_fingerprint (`str`, *opcional*, padrão `None`) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. desc (`str`, *opcional*, padrão `None`) : Descrição significativa para ser exibida junto com a barra de progresso durante o mapeamento de exemplos. try_original_type (`Optional[bool]`, padrão `True`) : Tenta manter os tipos das colunas originais (ex.: int32 -> int32). Defina como False se quiser sempre inferir novos tipos. on_mixed_types (`Literal["use_json"]`, *opcional*, padrão `None`) : Se "use_json", use o tipo Json() para campos de tipos mistos, ou seja, campos não estruturados que contêm dados sem um esquema predefinido. Nesse caso, um campo com tipo misto é definido como Json(). Isso permite carregar listas com uma mistura de strings/inteiros/floats, por exemplo, ou dicionários com tipos de valores arbitrários. Aplica uma função a todos os exemplos na tabela (individualmente ou em lotes) e atualiza a tabela. Se a sua função retornar uma coluna que já existe, ela a sobrescreve. Você pode especificar se a função deve ser processada em lote ou não com o parâmetro `batched`: - Se `False`, a função recebe 1 exemplo e deve retornar 1 exemplo. Um exemplo é um dicionário, por exemplo, `{"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 !"]}`. - Se `True` e `batch_size` é `n > 1`, a função recebe um lote de `n` exemplos como entrada e pode retornar um lote com `n` exemplos, ou com um número arbitrário de exemplos. Observe que o último lote pode ter menos de `n` exemplos. Um lote é um dicionário, por exemplo, um lote de `n` exemplos é `{"text": ["Hello there !"] * n}`. Se a função for assíncrona, `map` executará sua função em paralelo, com até mil chamadas simultâneas. É recomendável usar um `asyncio.Semaphore` na sua função se você quiser definir um número máximo de operações que podem ser executadas ao mesmo tempo. Exemplo: ```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) ``` #### filtro[[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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4149) **Parâmetros:** function (`Callable`) : Chamável com uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> bool` se `batched=False` e `with_indices=False` e `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` se `batched=False` e `with_indices=True` e/ou `with_rank=True` (um argumento extra para cada) - `function(batch: Dict[str, List]) -> List[bool]` se `batched=True` e `with_indices=False` e `with_rank=False` - `function(batch: Dict[str, List], *extra_args) -> List[bool]` se `batched=True` e `with_indices=True` e/ou `with_rank=True` (um argumento extra para cada) Se a função for assíncrona, o `filter` executará sua função em paralelo. Se nenhuma função for fornecida, o padrão é uma função sempre `True`: `lambda x: True`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, neste caso, a assinatura de `function` deve ser `def function(example, idx[, rank]): ...`. with_rank (`bool`, padrão `False`) : Fornece o rank do processo para `function`. Observe que, nesse caso, a assinatura de `function` deve ser `def function(example[, idx], rank): ...`. input_columns (`str` ou `List[str]`, *opcional*) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um `dict` mapeando para todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para a `function`. batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched = True`. Se `batched = False`, um exemplo por lote é passado para `function`. Se `batch_size <= 0` ou `batch_size == None`, forneça o conjunto de dados completo como um único lote para `function`. keep_in_memory (`bool`, padrão `False`) : Mantém o conjunto de dados em memória em vez de gravá-lo em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena o cálculo atual de `function` puder ser identificado, use-o em vez de recalcular. cache_file_name (`str`, *opcional*) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar os resultados do cálculo em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. fn_kwargs (`dict`, *opcional*) : Argumentos de palavra-chave a serem passados para `function`. num_proc (`int`, *opcional*, padrão `None`) : O número de processos a serem usados para multiprocessamento. - Se `None` ou `0`, nenhum multiprocessamento é usado e a operação é executada no processo principal. - Se for maior que `1`, um ou vários processos de trabalho são usados para processar dados em paralelo. Observação: A função passada para `map()` deve ser serializável (picklable) para que o multiprocessamento funcione corretamente (ou seja, prefira funções definidas no nível superior de um módulo, e não dentro de outra função ou classe). suffix_template (`str`) : Se `cache_file_name` for especificado, esse sufixo será adicionado ao final do nome base de cada arquivo. Por exemplo, se `cache_file_name` for `"processed.arrow"`, então para `rank = 1` e `num_proc = 4`, o arquivo resultante seria `"processed_00001_of_00004.arrow"` para o sufixo padrão (padrão `_{rank:05d}_of_{num_proc:05d}`). new_fingerprint (`str`, *opcional*) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. desc (`str`, *opcional*, padrão `None`) : Descrição significativa para ser exibida junto com a barra de progresso durante o filtramento de exemplos. Aplicar uma função de filtro a todos os elementos da tabela em lotes e atualizar a tabela para que o conjunto de dados inclua apenas exemplos de acordo com a função de filtro. Se a função for assíncrona, o `filter` executará sua função em paralelo, com até mil chamadas simultâneas (configurável). É recomendável usar um `asyncio.Semaphore` na sua função se você quiser definir um número máximo de operações que podem ser executadas ao mesmo tempo. Exemplo: ```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 }) ``` #### selecionar[[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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4376) **Parâmetros:** indices (`range`, `list`, `iterable`, `ndarray` ou `Series`) : Intervalo, lista ou array unidimensional de índices inteiros para indexação. Se os índices corresponderem a um intervalo contíguo, a tabela Arrow é simplesmente fatiada. No entanto, passar uma lista de índices que não são contíguos cria um mapeamento de índices, o que é muito menos eficiente, mas ainda assim mais rápido do que recriar uma tabela Arrow feita das linhas solicitadas. keep_in_memory (`bool`, padrão `False`) : Mantém o mapeamento de índices na memória em vez de gravá-lo em um arquivo de cache. indices_cache_file_name (`str`, *opcional*, padrão `None`) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar o mapeamento de índices em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. new_fingerprint (`str`, *opcional*, padrão `None`) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. Crie um novo dataset com as linhas selecionadas seguindo a lista/matriz de índices. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4717) **Parâmetros:** column_names (`Union[str, Sequence[str]]`) : Nome(s) da(s) coluna(s) para ordenação. reverse (`Union[bool, Sequence[bool]]`, padrão `False`) : Se `True`, ordena em ordem decrescente em vez de crescente. Se um único bool for fornecido, o valor é aplicado à ordenação de todos os nomes de colunas. Caso contrário, uma lista de bools com o mesmo comprimento e ordem que column_names deve ser fornecida. null_placement (`str`, padrão `at_end`) : Coloque valores `None` no início se `at_start` ou `first` ou no final se `at_end` ou `last` keep_in_memory (`bool`, padrão `False`) : Mantém os índices ordenados na memória em vez de gravá-los em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena os índices ordenados puder ser identificado, use-o em vez de recalculá-los. indices_cache_file_name (`str`, *opcional*, padrão `None`) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar os índices ordenados em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Um valor maior resulta em arquivos de cache menores, enquanto um valor menor consome menos memória temporária. new_fingerprint (`str`, *opcional*, padrão `None`) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação Crie um novo conjunto de dados ordenado de acordo com uma única coluna ou múltiplas colunas. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4845) **Parâmetros:** seed (`int`, *opcional*) : Uma semente para inicializar o BitGenerator padrão se `generator=None`. Se `None`, uma entropia fresca e imprevisível será obtida do SO. Se um `int` ou `array_like[ints]` for passado, ele será enviado ao SeedSequence para derivar o estado inicial do BitGenerator. generator (`numpy.random.Generator`, *opcional*) : Gerador aleatório do Numpy a ser usado para calcular a permutação das linhas do conjunto de dados. Se `generator=None` (padrão), usa `np.random.default_rng` (o BitGenerator padrão (PCG64) do NumPy). keep_in_memory (`bool`, padrão `False`) : Mantém os índices embaralhados na memória em vez de gravá-los em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena os índices embaralhados puder ser identificado, use-o em vez de recalculá-los. indices_cache_file_name (`str`, *opcional*) : Forneça o nome de um caminho para o arquivo de cache. Ele é usado para armazenar os índices embaralhados em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. new_fingerprint (`str`, *opcional*, padrão `None`) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação. Crie um novo Dataset em que as linhas são embaralhadas. Atualmente, o shuffling usa geradores aleatórios do numpy. Você pode fornecer um NumPy BitGenerator para usar ou uma seed para iniciar o gerador aleatório padrão do NumPy (PCG64). Shuffling pega a lista de índices `[0:len(my_dataset)]` e embaralha-a para criar um mapeamento de índices. No entanto, assim que seu [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) possui um mapeamento de índices, a velocidade pode ficar 10x mais lenta. Isso ocorre porque há uma etapa extra para obter o índice da linha a ser lido usando o mapeamento de índices e, mais importante, você não está mais lendo blocos contíguos de dados. Para restaurar a velocidade, você precisaria reescrever o conjunto de dados inteiro no seu disco novamente usando [Dataset.flatten_indices()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.flatten_indices), que remove o mapeamento de índices. Isso pode levar bastante tempo, dependendo do tamanho do seu conjunto de dados: ```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 ``` Nesse caso, recomendamos alternar para um [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) e aproveitar seu método rápido de embaralhamento aproximado [IterableDataset.shuffle()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.shuffle). Ele apenas embaralha a ordem dos shards e adiciona um buffer de embaralhamento ao seu dataset, mantendo a velocidade do seu dataset otimizada: ```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 ``` Exemplo: ```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] ``` #### pular[[datasets.Dataset.skip]] ```python skip(n: int) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4629) **Parâmetros:** n (`int`) : Número de elementos a serem ignorados. Crie um novo [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) que ignora os primeiros `n` elementos. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4691) **Parâmetros:** n (`int`) : Número de elementos a serem obtidos. Crie um novo [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) com apenas os primeiros `n` elementos. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4982) **Parâmetros:** test_size (`Union[float, int, None]`, *opcional*) : Tamanho da divisão de teste. Se `float`, deve estar entre `0.0` e `1.0` e representar a proporção do conjunto de dados a incluir na divisão de teste. Se `int`, representa o número absoluto de amostras de teste. Se `None`, o valor é definido como o complemento do tamanho do treino. Se `train_size` também for `None`, será definido como `0.25`. train_size (`Union[float, int, None]`, *opcional*) : Tamanho da divisão de treino. Se `float`, deve estar entre `0.0` e `1.0` e representar a proporção do conjunto de dados a incluir na divisão de treino. Se `int`, representa o número absoluto de amostras de treino. Se `None`, o valor é definido automaticamente como o complemento do tamanho do teste. shuffle (`bool`, *opcional*, padrão `True`) : Se os dados devem ser embaralhados antes da divisão. stratify_by_column (`str`, *opcional*, padrão `None`) : O nome da coluna de rótulos a ser usado para realizar a divisão estratificada dos dados. seed (`int`, *opcional*) : Uma semente para inicializar o BitGenerator padrão se `generator=None`. Se `None`, uma entropia fresca e imprevisível será obtida do SO. Se um `int` ou `array_like[ints]` for passado, ele será enviado ao SeedSequence para derivar o estado inicial do BitGenerator. generator (`numpy.random.Generator`, *opcional*) : Gerador aleatório do Numpy a ser usado para calcular a permutação das linhas do conjunto de dados. Se `generator=None` (padrão), usa `np.random.default_rng` (o BitGenerator padrão (PCG64) do NumPy). keep_in_memory (`bool`, padrão `False`) : Mantém os índices das divisões na memória em vez de gravá-los em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena os índices das divisões puder ser identificado, use-o em vez de recalculá-los. train_cache_file_name (`str`, *opcional*) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar os índices do split de treino em vez do nome do arquivo de cache gerado automaticamente. test_cache_file_name (`str`, *opcional*) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar os índices do conjunto de teste em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. train_new_fingerprint (`str`, *opcional*, padrão `None`) : A nova impressão digital do conjunto de treinamento após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação test_new_fingerprint (`str`, *opcional*, padrão `None`) : A nova impressão digital do conjunto de testes após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação Retorna um dicionário ([datasets.DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict)) com dois subconjuntos aleatórios de treino e teste (`train` e `test` `Dataset` splits). Os splits são criados a partir do dataset de acordo com `test_size`, `train_size` e `shuffle`. Este método é semelhante ao `train_test_split` do scikit-learn. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5265) **Parâmetros:** num_shards (`int`) : Quantos shards dividir o dataset. index (`int`) : Qual shard selecionar e retornar. contiguous : (`bool`, padrão `True`): Se deve selecionar blocos contíguos de índices para os shards. keep_in_memory (`bool`, padrão `False`) : Mantém o conjunto de dados em memória em vez de gravá-lo em um arquivo de cache. indices_cache_file_name (`str`, *opcional*) : Forneça o nome de um caminho para o arquivo de cache. Ele é usado para armazenar os índices de cada shard em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Isso se aplica apenas ao mapeamento de índices. Número de índices por operação de escrita para o escritor do arquivo de cache. Este valor representa um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. Retorna o shard de índice `index` do conjunto de dados dividido em `num_shards` partes. Isso faz o particionamento de forma determinística. `dataset.shard(n, i)` divide o conjunto de dados em blocos contíguos, de modo que ele possa ser facilmente concatenado novamente após o processamento. Se `len(dataset) % n == l`, então os primeiros `l` conjuntos de dados têm comprimento `(len(dataset) // n) + 1`, e os conjuntos de dados restantes têm comprimento `(len(dataset) // n)`. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` retorna um conjunto de dados com a mesma ordem que o original. Observação: n deve ser menor ou igual ao número de elementos no conjunto de dados `len(dataset)`. Por outro lado, `dataset.shard(n, i, contiguous=False)` contém todos os elementos do conjunto de dados cujo índice mod `n = i`. Certifique-se de fazer o sharding antes de usar qualquer operador de randomização (como `shuffle`). O ideal é que o operador de sharding seja usado no início do pipeline do dataset. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4659) **Parâmetros:** num_times (`int`) : Número de vezes para repetir o conjunto de dados. Crie um novo [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) que repete o dataset subjacente `num_times` vezes. Assim como itertools.repeat, repetir uma única vez retorna o conjunto de dados completo. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L336) **Parâmetros:** batch_size (`int`, *opcional*) : Tamanho dos lotes a serem carregados do conjunto de dados. O padrão é `None`, o que implica que o conjunto de dados não será loteado, mas o conjunto de dados retornado pode ser loteado posteriormente com `tf_dataset.batch(batch_size)`. columns (`List[str]` ou `str`, *opcional*) : Coluna(s) do dataset a carregar no `tf.data.Dataset`. Nomes de colunas criados pelo `collate_fn` e que não existem no dataset original podem ser usados. shuffle(`bool`, padrão `False`) : Embaralha a ordem do conjunto de dados ao carregar. Recomendado `True` para treinamento, `False` para validação/avaliação. drop_remainder(`bool`, padrão `False`) : Descarta o último lote incompleto ao carregar. Garante que todos os lotes gerados pelo conjunto de dados tenham o mesmo comprimento na dimensão do lote. collate_fn(`Callable`, *opcional*) : Uma função ou objeto chamável (como um `DataCollator`) que agrupará listas de amostras em um lote. collate_fn_args (`Dict`, *opcional*) : Um `dict` opcional de argumentos de palavra-chave a serem passados para o `collate_fn`. label_cols (`List[str]` ou `str`, padrão `None`) : Coluna(s) do dataset para carregar como rótulos. Observe que muitos modelos calculam a perda internamente, em vez de deixar o Keras fazer isso, caso em que a passagem dos rótulos aqui é opcional, desde que estejam nas `columns` de entrada. prefetch (`bool`, padrão `True`) : Se o dataloader deve ser executado em uma thread separada e manter um pequeno buffer de lotes para o treinamento. Melhora o desempenho ao permitir que os dados sejam carregados em segundo plano enquanto o modelo está em treinamento. num_workers (`int`, padrão `0`) : Número de workers a serem usados para carregar o dataset. num_test_batches (`int`, padrão `20`) : Número de lotes usados para inferir a assinatura de saída do conjunto de dados. Quanto maior esse número, mais precisa será a assinatura, mas mais tempo levará para criar o conjunto de dados. **Retorna:** `tf.data.Dataset` Crie um `tf.data.Dataset` a partir do Dataset subjacente. Este `tf.data.Dataset` carregará e agrupará lotes do Dataset e é adequado para passar a métodos como `model.fit()` ou `model.predict()`. O dataset produzirá `dicts` tanto para entradas quanto para rótulos, a menos que o `dict` contenha apenas uma única chave, caso em que um `tf.Tensor` bruto será produzido em vez disso. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6092) **Parâmetros:** repo_id (`str`) : O ID do repositório para o qual será feito o push, no seguinte formato: `/` ou `/`. Também aceita ``, que usará o namespace do usuário conectado por padrão. Também pode ser um local dentro de um bucket, por exemplo, `buckets///...` config_name (`str`, padrão "default") : O nome da configuração (ou subconjunto) de um conjunto de dados. Padrão é "default". set_default (`bool`, *opcional*) : Se deve definir esta configuração como a padrão. Caso contrário, a configuração padrão é a nomeada "default". split (`str`, *opcional*) : O nome da divisão que será atribuído a esse conjunto de dados. O padrão é `self.split`. data_dir (`str`, *opcional*) : Nome do diretório que conterá os arquivos de dados enviados. O padrão é `config_name` se for diferente de "default", caso contrário, "data". commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O padrão será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descrição do commit que será criado. Além disso, descrição da PR, caso uma PR seja criada (`create_pr` é True). private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir. token (`str`, *opcional*) : Um token de autenticação opcional para o Hugging Face Hub. Se nenhum token for passado, será usado o token salvo localmente ao fazer login com `hf auth login`. Será gerado um erro se nenhum token for passado e o usuário não estiver conectado. revision (`str`, *opcional*) : Branch para o qual os arquivos enviados serão enviados. O padrão é a branch `"main"`. create_pr (`bool`, *opcional*, padrão `False`) : Se deve criar um PR com os arquivos enviados ou fazer o commit diretamente. max_shard_size (`int` ou `str`, *opcional*, padrão `"500MB"`) : O tamanho máximo dos shards do dataset a serem enviados para o hub. Se expresso como string, deve ser composto por dígitos seguidos por uma unidade (como `"5MB"`). num_shards (`int`, *opcional*) : Número de shards a serem gravados. Por padrão, o número de shards depende de `max_shard_size`. embed_external_files (`bool`, padrão `True`) : Se deve incorporar os bytes dos arquivos nos shards. Em particular, isso fará o seguinte antes do push para os campos do tipo: - [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) e [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image): remover as informações de caminho local e incorporar o conteúdo do arquivo nos arquivos Parquet. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao preparar e enviar o dataset. Isso é útil se o dataset for composto por muitas amostras ou arquivos de mídia para incorporar. Usa o contexto "spawn" para funcionar com hf_xet, o cliente rust para uploads rápidos para o HF. O multiprocessing é desabilitado por padrão. **Retorna:** huggingface_hub.CommitInfo Envia o dataset para o hub como um dataset Parquet. O dataset é enviado usando solicitações HTTP e não requer a instalação de git ou git-lfs. Os arquivos Parquet resultantes são autossuficientes por padrão. Se o seu conjunto de dados contiver dados de [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) ou [Video](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Video), os arquivos Parquet armazenarão os bytes das suas imagens ou arquivos de áudio. Você pode desativar isso definindo `embed_external_files` como `False`. Exemplo: ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Se o seu conjunto de dados tiver várias divisões (por exemplo, treino/validação/teste): ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Se você deseja adicionar uma nova configuração (ou subconjunto) a um conjunto de dados (por exemplo, se o conjunto de dados tiver várias tarefas/versões/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1781) **Parâmetros:** dataset_path (`path-like`) : Path (por exemplo, `dataset/train`) ou URI remoto (por exemplo, `s3://my-bucket/dataset/train`) do diretório do dataset onde o dataset será salvo. max_shard_size (`int` ou `str`, *opcional*, padrão `"500MB"`) : O tamanho máximo dos shards do dataset a serem salvos no sistema de arquivos. Se expresso como uma string, precisa ser dígitos seguidos por uma unidade (como `"50MB"`). num_shards (`int`, *opcional*) : Número de shards a serem gravados. Por padrão, o número de shards depende de `max_shard_size` e `num_proc`. num_proc (`int`, *opcional*) : Número de processos ao baixar e gerar o dataset localmente. O multiprocessing é desabilitado por padrão. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. Salva um conjunto de dados em um diretório de conjunto de dados ou em um sistema de arquivos usando qualquer implementação de `fsspec.spec.AbstractFileSystem`. Para dados de [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) e [Video](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Video): Todos os dados de Image(), Audio() e Video() são armazenados nos arquivos arrow. Se você deseja armazenar caminhos ou urls, use o tipo Value("string"). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1989) **Parâmetros:** dataset_path (`path-like`) : Path (por exemplo, `"dataset/train"`) ou URI remoto (por exemplo, `"s3//my-bucket/dataset/train"`) do diretório do dataset de onde o dataset será carregado. keep_in_memory (`bool`, padrão `None`) : Se deve copiar o dataset em memória. Se `None`, o dataset não será copiado em memória, a menos que seja explicitamente habilitado ao definir `datasets.config.IN_MEMORY_MAX_SIZE` para um valor diferente de zero. Veja mais detalhes na seção [melhorar o desempenho](../cache#improve-performance). storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) ou [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) - Se `dataset_path` for um caminho de um diretório de dataset, o dataset solicitado. - Se `dataset_path` for um caminho para um diretório de dicionário de datasets, um `datasets.DatasetDict` com cada split. Carrega um conjunto de dados que foi salvo anteriormente usando `save_to_disk` a partir de um diretório de conjunto de dados, ou de um sistema de arquivos usando qualquer implementação de `fsspec.spec.AbstractFileSystem`. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L4297) **Parâmetros:** keep_in_memory (`bool`, padrão `False`) : Mantém o conjunto de dados em memória em vez de gravá-lo em um arquivo de cache. cache_file_name (`str`, *opcional*, padrão `None`) : Fornece o nome de um caminho para o arquivo de cache. É usado para armazenar os resultados do cálculo em vez do nome do arquivo de cache gerado automaticamente. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. features (`Optional[datasets.Features]`, padrão `None`) : Use um [Features](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features) específico para armazenar o arquivo de cache em vez do gerado automaticamente. disable_nullable (`bool`, padrão `False`) : Permite valores nulos na tabela. num_proc (`int`, opcional, padrão `None`) : Número máximo de processos ao gerar o cache. Os shards já em cache são carregados sequencialmente new_fingerprint (`str`, *opcional*, padrão `None`) : A nova impressão digital do conjunto de dados após a transformação. Se `None`, a nova impressão digital é calculada usando um hash da impressão digital anterior e dos argumentos da transformação Crie e cacheie um novo Dataset aplanando o mapeamento de índices. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5342) **Parâmetros:** path_or_buf (`PathLike` ou `FileOrBuffer`) : Um caminho para um arquivo (por exemplo, `file.csv`), um URI remoto (por exemplo, `hf://datasets/username/my_dataset_name/data.csv`) ou um BinaryIO, onde o conjunto de dados será salvo no formato especificado. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *opcional*) : Número de processos para multiprocessamento. Por padrão, não utiliza multiprocessamento. Nesse caso, `batch_size` é definido como `datasets.config.DEFAULT_MAX_BATCH_SIZE` por padrão, mas sinta-se à vontade para aumentá-lo para 5x ou 10x do valor padrão, caso tenha poder de computação suficiente. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. - ****to_csv_kwargs** (argumentos de palavra-chave adicionais): Parâmetros para passar ao [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) do pandas. Agora, `index` tem o valor padrão `False` se não for especificado. Se você deseja gravar o índice, passe `index=True` e também defina um nome para a coluna de índice passando `index_label`. **Retorna:** `int` O número de caracteres ou bytes gravados. Exporta o conjunto de dados para csv Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5541) **Parâmetros:** batch_size (`int`, *opcional*) : O tamanho (número de linhas) dos lotes se `batched` for `True`. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Defina como `True` para retornar um gerador que produz o conjunto de dados em lotes de `batch_size` linhas. O valor padrão é `False` (retorna todo o conjunto de dados de uma vez). **Retorna:** `pandas.DataFrame` ou `Iterator[pandas.DataFrame]` Retorna o conjunto de dados como um `pandas.DataFrame`. Também pode retornar um gerador para conjuntos de dados grandes. Exemplo: ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.Dataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5401) **Parâmetros:** batch_size (`int`, *opcional*) : O tamanho (número de linhas) dos lotes se `batched` for `True`. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Defina como `True` para retornar um gerador que produz o conjunto de dados em lotes de `batch_size` linhas. O valor padrão é `False` (retorna todo o conjunto de dados de uma vez). **Retorna:** `dict` ou `Iterator[dict]` Retorna o conjunto de dados como um dicionário Python. Também pode retornar um gerador para conjuntos de dados grandes. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5466) **Parâmetros:** path_or_buf (`PathLike` ou `FileOrBuffer`) : Um caminho para um arquivo (por exemplo, `file.json`), um URI remoto (por exemplo, `hf://datasets/username/my_dataset_name/data.json`) ou um BinaryIO, onde o conjunto de dados será salvo no formato especificado. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *opcional*) : Número de processos para multiprocessamento. Por padrão, não utiliza multiprocessamento. Nesse caso, `batch_size` é definido como `datasets.config.DEFAULT_MAX_BATCH_SIZE` por padrão, mas sinta-se à vontade para aumentá-lo para 5x ou 10x do valor padrão, caso tenha capacidade de computação suficiente. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. - ****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`. **Retorna:** `int` O número de caracteres ou bytes gravados. Exporte o conjunto de dados para JSON Lines ou JSON. O formato de saída padrão é [JSON Lines](https://jsonlines.org/). Para exportar para [JSON](https://www.json.org), passe o argumento `lines=False` e o `orient` desejado. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5643) **Parâmetros:** path_or_buf (`PathLike` ou `FileOrBuffer`) : Um caminho para um arquivo (por exemplo, `file.parquet`), um URI remoto (por exemplo, `hf://datasets/username/my_dataset_name/data.parquet`) ou um BinaryIO, onde o conjunto de dados será salvo no formato especificado. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. Por padrão, visa grupos de linhas com tamanho máximo descompactado de "100MB", definido por `datasets.config.MAX_ROW_GROUP_SIZE`. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. - ****parquet_writer_kwargs** (argumentos de palavra-chave adicionais) : Parâmetros para passar ao `pyarrow.parquet.ParquetWriter` do PyArrow. **Retorna:** `int` O número de caracteres ou bytes gravados. Exporta o conjunto de dados para parquet Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5683) **Parâmetros:** name (`str`) : Nome da tabela SQL. con (`str` ou `sqlite3.Connection` ou `sqlalchemy.engine.Connection` ou `sqlalchemy.engine.Connection`) : Uma [string URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) ou um objeto de conexão SQLite3/SQLAlchemy usado para gravar em um banco de dados. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. num_proc (`int`, *opcional*) : Número de processos para multiprocessamento. Por padrão, não utiliza multiprocessamento. Nesse caso, `batch_size` é definido como `datasets.config.DEFAULT_MAX_BATCH_SIZE` por padrão, mas sinta-se à vontade para aumentá-lo para 5x ou 10x do valor padrão, caso tenha capacidade de computação suficiente. - ****sql_writer_kwargs** (argumentos de palavra-chave adicionais) : Parâmetros para passar ao [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) do pandas. Agora, `index` tem como padrão `False` se não for especificado. Se você deseja gravar o índice, passe `index=True` e também defina um nome para a coluna de índice passando `index_label`. **Retorna:** `int` O número de registros gravados. Exporta o conjunto de dados para um banco de dados SQL. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L5781) **Parâmetros:** num_shards (`int`, padrão `1`) : Número de shards a definir ao instanciar o dataset iterável. Isso é especialmente útil para datasets grandes, permitindo embaralhar corretamente e também habilitar carregamento paralelo rápido usando um PyTorch DataLoader ou em configurações distribuídas, por exemplo. Os shards são definidos usando [datasets.Dataset.shard()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.shard): eles simplesmente fatiam os dados sem gravar nada em disco. **Retorna:** [datasets.IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Obtenha um [datasets.IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) a partir de um [datasets.Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) de estilo mapa. Isso é equivalente a carregar um dataset em modo de streaming com [datasets.load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset), mas muito mais rápido, pois os dados são transmitidos a partir de arquivos locais. Ao contrário dos datasets no estilo mapa, os datasets iteráveis são preguiçosos e podem apenas ser iterados (por exemplo, usando um laço for). Como são lidos sequencialmente nos loops de treinamento, os datasets iteráveis são muito mais rápidos do que os datasets no estilo mapa. Todas as transformações aplicadas a datasets iteráveis, como filtragem ou processamento, são feitas em tempo real quando você começa a iterar sobre o dataset. Ainda assim, é possível embaralhar um dataset iterável usando [datasets.IterableDataset.shuffle()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.shuffle). Este é um embaralhamento aproximado rápido que funciona melhor se você tiver vários shards e especificar um tamanho de buffer suficientemente grande. Para obter o melhor desempenho de velocidade, verifique se o seu conjunto de dados não possui um mapeamento de índices. Se esse for o caso, os dados não são lidos de forma contígua, o que pode ser lento em alguns momentos. Você pode usar `ds = ds.flatten_indices()` para gravar seu conjunto de dados em blocos contíguos de dados e ter a velocidade ideal antes de alternar para um conjunto de dados iterável. Exemplo: Uso básico: ```python >>> ids = ds.to_iterable_dataset() >>> for example in ids: ... pass ``` Com filtragem e processamento preguiçosos: ```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 ``` Com sharding para permitir shuffling eficiente: ```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 ``` Com um DataLoader do PyTorch: ```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 ``` Com um DataLoader do PyTorch e embaralhamento: ```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 ``` Em uma configuração distribuída como PyTorch DDP com um PyTorch DataLoader e embaralhamento ```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 ``` Com embaralhamento e múltiplas épocas: ```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 ``` Sinta-se à vontade para também usar `IterableDataset.set_epoch()` ao utilizar um PyTorch DataLoader ou em configurações distribuídas. #### 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 = ) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6339) **Parâmetros:** column (`str`) : A coluna dos vetores a serem adicionados ao índice. index_name (`str`, *opcional*) : O `index_name`/identificador do índice. Este é o `index_name` usado para chamar [get_nearest_examples()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.get_nearest_examples) ou [search()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.search). Por padrão, corresponde a `column`. device (`Union[int, List[int]]`, *opcional*) : Se for um inteiro positivo, este é o índice da GPU a ser usada. Se for um inteiro negativo, usa todas as GPUs. Se uma lista de inteiros positivos for passada, executa apenas nessas GPUs. Por padrão, usa a CPU. string_factory (`str`, *opcional*) : Isso é passado para a fábrica de índices do Faiss para criar o índice. A classe de índice padrão é `IndexFlat`. metric_type (`int`, *opcional*) : Tipo de métrica. Ex: `faiss.METRIC_INNER_PRODUCT` ou `faiss.METRIC_L2`. custom_index (`faiss.Index`, *opcional*) : Índice Faiss personalizado que você já instanciou e configurou para suas necessidades. batch_size (`int`) : Tamanho do lote a ser usado ao adicionar vetores ao `FaissIndex`. O valor padrão é `1000`. train_size (`int`, *opcional*) : Se o índice precisar de uma etapa de treinamento, especifica quantos vetores serão usados para treinar o índice. faiss_verbose (`bool`, padrão `False`) : Ativa a verbosidade do índice Faiss. dtype (`data-type`) : O dtype dos arrays numpy que são indexados. O padrão é `np.float32`. Adicione um índice denso usando Faiss para recuperação rápida. Por padrão, o índice é feito sobre os vetores da coluna especificada. Você pode especificar `device` se quiser executá-lo na GPU (`device` deve ser o índice da GPU). Você pode encontrar mais informações sobre o Faiss aqui: - Para [fábrica de strings](https://github.com/facebookresearch/faiss/wiki/The-index-factory) Exemplo: ```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 = ) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6419) **Parâmetros:** external_arrays (`np.array`) : Se você deseja usar arrays de fora da lib para o índice, pode definir `external_arrays`. Ele usará `external_arrays` para criar o índice Faiss em vez dos arrays na `column` fornecida. index_name (`str`) : O `index_name`/identificador do índice. Este é o `index_name` usado para chamar [get_nearest_examples()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.get_nearest_examples) ou [search()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.search). device (Opcional `Union[int, List[int]]`, *opcional*) : Se for um inteiro positivo, este é o índice da GPU a ser usada. Se for um inteiro negativo, usa todas as GPUs. Se uma lista de inteiros positivos for passada, executa apenas nessas GPUs. Por padrão, usa a CPU. string_factory (`str`, *opcional*) : Isso é passado para a fábrica de índices do Faiss para criar o índice. A classe de índice padrão é `IndexFlat`. metric_type (`int`, *opcional*) : Tipo de métrica. Ex: `faiss.faiss.METRIC_INNER_PRODUCT` ou `faiss.METRIC_L2`. custom_index (`faiss.Index`, *opcional*) : Índice Faiss personalizado que você já instanciou e configurou para suas necessidades. batch_size (`int`, *opcional*) : Tamanho do lote a ser usado ao adicionar vetores ao FaissIndex. O valor padrão é 1000. train_size (`int`, *opcional*) : Se o índice precisar de uma etapa de treinamento, especifica quantos vetores serão usados para treinar o índice. faiss_verbose (`bool`, padrão é False) : Ativa a verbosidade do índice Faiss. dtype (`numpy.dtype`) : O dtype dos arrays numpy que são indexados. O padrão é np.float32. Adicione um índice denso usando Faiss para recuperação rápida. O índice é criado usando os vetores de `external_arrays`. Você pode especificar `device` se quiser executá-lo na GPU (`device` deve ser o índice da GPU). Você pode encontrar mais informações sobre o Faiss aqui: - Para [fábrica de strings](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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L535) **Parâmetros:** index_name (`str`) : O index_name/identificador do índice. Este é o index_name usado para chamar `.get_nearest` ou `.search`. file (`str`) : O caminho para o índice faiss serializado no disco ou URI remoto (por exemplo, `"s3://my-bucket/index.faiss"`). storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. Salve um FaissIndex em disco. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L553) **Parâmetros:** index_name (`str`) : O index_name/identificador do índice. Este é o index_name usado para chamar `.get_nearest` ou `.search`. file (`str`) : O caminho para o índice faiss serializado no disco ou URI remoto (por exemplo, `"s3://my-bucket/index.faiss"`). device (Opcional `Union[int, List[int]]`) : Se for um inteiro positivo, este é o índice da GPU a ser usada. Se for um inteiro negativo, usa todas as GPUs. Se uma lista de inteiros positivos for passada, executa apenas nessas GPUs. Por padrão, usa a CPU. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. Carregue um FaissIndex do disco. Se você quiser fazer configurações adicionais, pode ter acesso ao objeto de índice faiss executando `.get_index(index_name).faiss_index` para adaptá-lo às suas necessidades. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6478) **Parâmetros:** column (`str`) : A coluna dos documentos a serem adicionados ao índice. index_name (`str`, *opcional*) : O `index_name`/identificador do índice. Este é o nome do índice usado para chamar [get_nearest_examples()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.get_nearest_examples) ou [search()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.search). Por padrão, corresponde a `column`. host (`str`, *opcional*, padrão `localhost`) : Host onde o ElasticSearch está em execução. port (`str`, *opcional*, padrão `9200`) : Porta em que o ElasticSearch está em execução. es_client (`elasticsearch.Elasticsearch`, *opcional*) : O cliente elasticsearch usado para criar o índice se host e port forem `None`. es_index_name (`str`, *opcional*) : O nome do índice elasticsearch usado para criar o índice. es_index_config (`dict`, *opcional*) : A configuração do índice do elasticsearch. A configuração padrão é: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Adicione um índice de texto usando ElasticSearch para recuperação rápida. Isso é feito in-place. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L637) **Parâmetros:** index_name (`str`) : O `index_name`/identificador do índice. Este é o nome do índice usado para chamar `get_nearest` ou `search`. es_index_name (`str`) : O nome do índice do elasticsearch a ser carregado. host (`str`, *opcional*, padrão `localhost`) : Host onde o ElasticSearch está em execução. port (`str`, *opcional*, padrão `9200`) : Porta em que o ElasticSearch está em execução. es_client (`elasticsearch.Elasticsearch`, *opcional*) : O cliente elasticsearch usado para criar o índice se host e port forem `None`. es_index_config (`dict`, *opcional*) : A configuração do índice do elasticsearch. A configuração padrão é: ``` { "settings": { "number_of_shards": 1, "analysis": {"analyzer": {"stop_standard": {"type": "standard", " stopwords": "_english_"}}}, }, "mappings": { "properties": { "text": { "type": "text", "analyzer": "standard", "similarity": "BM25" }, } }, } ``` Carregue um índice de texto existente usando ElasticSearch para recuperação rápida. #### list_indexes[[datasets.Dataset.list_indexes]] ```python list_indexes() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L438) Liste os `colindex_nameumns`/identificadores de todos os índices anexados. #### get_index[[datasets.Dataset.get_index]] ```python get_index(index_name: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L442) **Parâmetros:** index_name (`str`) : Nome do índice. **Retorna:** `BaseIndex` Liste o `index_name`/identificadores de todos os índices anexados. #### drop_index[[datasets.Dataset.drop_index]] ```python drop_index(index_name: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L684) **Parâmetros:** index_name (`str`) : O `index_name`/identificador do índice. Remova o índice com a coluna especificada. #### pesquisar[[datasets.Dataset.search]] ```python search(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L693) **Parâmetros:** index_name (`str`) : O nome/identificador do índice. query (`Union[str, np.ndarray]`) : A consulta como uma string se `index_name` for um índice de texto ou como um array numpy se `index_name` for um índice de vetor. k (`int`) : O número de exemplos a serem recuperados. **Retorna:** `(scores, indices)` Uma tupla de `(scores, indices)` onde: - **scores** (`List[List[float]`): as pontuações de recuperação dos exemplos recuperados, obtidas do FAISS (`IndexFlatL2` por padrão) ou do ElasticSearch - **indices** (`List[List[int]]`): os índices dos exemplos recuperados Encontre os índices dos exemplos mais próximos no conjunto de dados em relação à consulta. #### search_batch[[datasets.Dataset.search_batch]] ```python search_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L713) **Parâmetros:** index_name (`str`) : O `index_name`/identificador do índice. queries (`Union[List[str], np.ndarray]`) : As consultas como uma lista de strings se `index_name` for um índice de texto ou como um array numpy se `index_name` for um índice de vetor. k (`int`) : O número de exemplos a serem recuperados por consulta. **Retorna:** `(total_scores, total_indices)` Uma tupla de `(total_scores, total_indices)` onde: - **total_scores** (`List[List[float]`): as pontuações de recuperação dos exemplos recuperados por consulta, obtidas do FAISS (`IndexFlatL2` por padrão) ou do ElasticSearch - **total_indices** (`List[List[int]]`): os índices dos exemplos recuperados por consulta Encontre os índices dos exemplos mais próximos no conjunto de dados em relação à consulta. #### get_nearest_examples[[datasets.Dataset.get_nearest_examples]] ```python get_nearest_examples(index_name: str, query: typing.Union[str, ], k: int = 10, **kwargs) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L735) **Parâmetros:** index_name (`str`) : O index_name/identificador do índice. query (`Union[str, np.ndarray]`) : A consulta como uma string se `index_name` for um índice de texto ou como um array numpy se `index_name` for um índice de vetor. k (`int`) : O número de exemplos a serem recuperados. **Retorna:** `(scores, examples)` Uma tupla de `(scores, examples)` onde: - **scores** (`List[float]`): as pontuações de recuperação dos exemplos recuperados, obtidas do FAISS (`IndexFlatL2` por padrão) ou do ElasticSearch - **exemplos** (`dict`): os exemplos recuperados Encontre os exemplos mais próximos no conjunto de dados em relação à consulta. #### get_nearest_examples_batch[[datasets.Dataset.get_nearest_examples_batch]] ```python get_nearest_examples_batch(index_name: str, queries: typing.Union[list[str], ], k: int = 10, **kwargs) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/search.py#L759) **Parâmetros:** index_name (`str`) : O `index_name`/identificador do índice. queries (`Union[List[str], np.ndarray]`) : As consultas como uma lista de strings se `index_name` for um índice de texto ou como um array numpy se `index_name` for um índice de vetor. k (`int`) : O número de exemplos a serem recuperados por consulta. **Retorna:** `(total_scores, total_examples)` Uma tupla de `(total_scores, total_examples)` onde: - **total_scores** (`List[List[float]`): as pontuações de recuperação dos exemplos recuperados por consulta, obtidas do FAISS (`IndexFlatL2` por padrão) ou do ElasticSearch - **total_examples** (`List[dict]`): os exemplos recuperados por consulta Encontre os exemplos mais próximos no conjunto de dados em relação à consulta. #### info[[datasets.Dataset.info]] ```python info() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172) Objeto [DatasetInfo](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetInfo) contendo todos os metadados do conjunto de dados. #### split[[datasets.Dataset.split]] ```python split() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177) objeto [NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit) correspondente a uma divisão nomeada do conjunto de dados. #### builder_name[[datasets.Dataset.builder_name]] ```python builder_name() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182) #### citação[[datasets.Dataset.citation]] ```python citation() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.Dataset.config_name]] ```python config_name() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.Dataset.dataset_size]] ```python dataset_size() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194) #### descrição[[datasets.Dataset.description]] ```python description() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.Dataset.download_checksums]] ```python download_checksums() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.Dataset.download_size]] ```python download_size() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206) #### recursos[[datasets.Dataset.features]] ```python features() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L785) #### página inicial[[datasets.Dataset.homepage]] ```python homepage() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214) #### licença[[datasets.Dataset.license]] ```python license() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.Dataset.size_in_bytes]] ```python size_in_bytes() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.Dataset.supervised_keys]] ```python supervised_keys() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226) #### versão[[datasets.Dataset.version]] ```python version() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230) #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1282) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) CSV. split ([NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao baixar e gerar o dataset localmente. Isso é útil se o dataset for composto por vários arquivos. O multiprocessing é desabilitado por padrão. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `pandas.read_csv`. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Crie um Dataset a partir de arquivo(s) CSV. Leia os arquivos CSV, cacheie os dados em formato Arrow no disco e retorne o Dataset a partir dos dados Arrow mapeados na memória no disco. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1422) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) JSON ou JSON Lines. split ([NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. field (`str`, *opcional*) : Nome do campo do arquivo JSON onde o conjunto de dados está contido. num_proc (`int`, *opcional* padrão é `None`) : Número de processos ao baixar e gerar o dataset localmente. Isso é útil se o dataset for composto por vários arquivos. O multiprocessing é desabilitado por padrão. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `JsonConfig`. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Crie um Dataset a partir de arquivo(s) JSON ou JSON Lines. Leia os arquivos JSON, cacheie os dados em formato Arrow no disco e retorne o Dataset a partir dos dados Arrow mapeados na memória no disco. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1481) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) Parquet. split (`NamedSplit`, *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features (`Features`, *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. columns (`List[str]`, *opcional*) : Se não for `None`, apenas essas colunas serão lidas do arquivo. O nome de uma coluna pode ser um prefixo de um campo aninhado, por exemplo, 'a' selecionará 'a.b', 'a.c' e 'a.d.e'. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao baixar e gerar o dataset localmente. Isso é útil se o dataset for composto por vários arquivos. O multiprocessing é desabilitado por padrão. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *opcional*) : Retorna apenas as linhas que correspondem ao filtro. Se possível, o predicado será empurrado para baixo para explorar as informações de particionamento ou os metadados internos encontrados na fonte de dados, por exemplo, estatísticas do Parquet. Caso contrário, filtra os RecordBatches carregados antes de retorná-los. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *opcional*) : Opções específicas de varredura para fragmentos Parquet. Isso é especialmente útil para configurar bufferização e cache. on_bad_files (`Literal["error", "warn", "skip"]`, *opcional*, padrão "error") : Especifica o que fazer ao encontrar um arquivo inválido (um arquivo que não pode ser lido). Os valores permitidos são: * 'error', lança uma Exception quando um arquivo inválido é encontrado. * 'warn', lança um aviso quando um arquivo inválido é encontrado e ignora esse arquivo. * 'skip', ignora arquivos inválidos sem lançar exceção ou aviso quando são encontrados. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `ParquetConfig`. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Crie um Dataset a partir de arquivo(s) Parquet. Leia os arquivos Parquet, cacheie os dados em formato Arrow no disco e retorne o Dataset a partir dos dados Arrow mapeados na memória no disco. Exemplo: ```py >>> ds = Dataset.from_parquet('path/to/dataset.parquet') ``` Carregue um subconjunto de colunas: ```python >>> ds = Dataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Filtre dados de forma eficiente, possivelmente pulando arquivos inteiros ou grupos de linhas: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1578) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) de texto. split (`NamedSplit`, *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features (`Features`, *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao baixar e gerar o dataset localmente. Isso é útil se o dataset for composto por vários arquivos. O multiprocessing é desabilitado por padrão. keep_linebreaks : (`bool`, padrão é False): Se deve manter quebras de linha. sample_by (`Literal["line", "paragraph", "document"]`, padrão "line") : Se os dados devem ser carregados por linha, parágrafo ou documento. Por padrão, uma linha no dataset = uma linha. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `TextConfig`. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Crie um Dataset a partir de arquivo(s) de texto. Leia os arquivos de texto, cacheie os dados em formato Arrow no disco e retorne o Dataset a partir dos dados Arrow mapeados na memória no disco. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L1706) **Parâmetros:** sql (`str` ou `sqlalchemy.sql.Selectable`) : consulta SQL a ser executada ou nome de uma tabela. con (`str` ou `sqlite3.Connection` ou `sqlalchemy.engine.Connection` ou `sqlalchemy.engine.Connection`) : Uma [string URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) usada para instanciar uma conexão de banco de dados ou um objeto de conexão SQLite3/SQLAlchemy. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `SqlConfig`. **Retorna:** [Conjunto de dados](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) Crie um Dataset a partir de uma consulta SQL ou de uma tabela de banco de dados. Consulte o banco de dados SQL, cacheie os dados em formato Arrow no disco e retorne o Dataset a partir dos dados Arrow mapeados na memória no disco. Exemplo: ```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] > O conjunto de dados retornado só pode ser armazenado em cache se `con` for especificado como uma string URI. #### align_labels_with_mapping[[datasets.Dataset.align_labels_with_mapping]] ```python align_labels_with_mapping(label2id: dict, label_column: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L6600) **Parâmetros:** label2id (`dict`) : O mapeamento de nome de rótulo para ID com o qual alinhar o conjunto de dados. label_column (`str`) : O nome da coluna de rótulos para alinhar. Alinhe o mapeamento de ID e nome de rótulos do conjunto de dados para corresponder a um mapeamento de entrada `label2id`. Isso é útil quando você deseja garantir que os rótulos previstos por um modelo estejam alinhados com o conjunto de dados. O alinhamento é feito usando os nomes de rótulos em minúsculas. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L168) **Parâmetros:** dsets (`List[datasets.Dataset]` ou `List[datasets.IterableDataset]`) : Lista de Datasets para concatenar. info (`DatasetInfo`, *opcional*) : Informações do dataset, como descrição, citação, etc. split (`NamedSplit`, *opcional*) : Nome da divisão do conjunto de dados. axis (`{0, 1}`, padrão `0`) : Eixo para concatenação, onde `0` significa sobre as linhas (verticalmente) e `1` significa sobre as colunas (horizontalmente). Concatene vários conjuntos de dados (fontes) em um único conjunto de dados. Use axis=0 para concatenar verticalmente (padrão) ou axis=1 para concatenar horizontalmente. Observação para conjuntos de dados iteráveis: * se axis=0, o `num_shards` do dataset resultante é a soma dos `num_shards` de cada dataset. * se axis=1, o dataset resultante tem um (1) shard para não desalinhar os dados. * se os conjuntos de dados foram divididos com [datasets.distributed.split_dataset_by_node()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.distributed.split_dataset_by_node), todos eles devem ser divididos da mesma forma, e o conjunto de dados resultante mantém essa divisão. Exemplo: ```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') ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/combine.py#L18) **Parâmetros:** datasets (`List[Dataset]` ou `List[IterableDataset]`) : Lista de conjuntos de dados para intercalar. probabilities (`List[float]`, *opcional*, padrão `None`) : Se especificado, o novo conjunto de dados é construído amostrando exemplos de uma fonte por vez de acordo com essas probabilidades. seed (`int`, *opcional*, padrão `None`) : A semente aleatória usada para escolher uma fonte para cada exemplo. info ([DatasetInfo](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetInfo), *opcional*) : Informações do dataset, como descrição, citação, etc. split ([NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nome da divisão do conjunto de dados. stopping_strategy (`str`, padrão `first_exhausted`) : Três estratégias são propostas no momento, `first_exhausted`, `all_exhausted` e `all_exhausted_without_replacement`. Por padrão, `first_exhausted` é uma estratégia de subamostragem, ou seja, a construção do conjunto de dados é interrompida assim que um dos conjuntos de dados ficar sem amostras. Se a estratégia for `all_exhausted`, usamos uma estratégia de sobreamostragem, ou seja, a construção do conjunto de dados é interrompida assim que todas as amostras de todos os conjuntos de dados tiverem sido adicionadas pelo menos uma vez. Quando a estratégia é `all_exhausted_without_replacement`, garantimos que cada amostra em cada conjunto de dados seja amostrada apenas uma vez. Observe que, se a estratégia for `all_exhausted`, o tamanho do conjunto de dados intercalado pode ficar enorme: - sem probabilidades, o conjunto de dados resultante terá `max_length_datasets*nb_dataset` amostras. - com probabilidades dadas, o conjunto de dados resultante terá mais amostras se alguns conjuntos de dados tiverem uma probabilidade muito baixa de serem visitados. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) O tipo de retorno depende do parâmetro de entrada `datasets`. `Dataset` se a entrada for uma lista de `Dataset`, `IterableDataset` se a entrada for uma lista de `IterableDataset`. Intercale vários conjuntos de dados (fontes) em um único conjunto de dados. O novo conjunto de dados é construído alternando entre as fontes para obter os exemplos. Você pode usar esta função em uma lista de objetos [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) ou em uma lista de objetos [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset). - Se `probabilities` for `None` (padrão), o novo conjunto de dados é construído alternando entre cada fonte para obter os exemplos. - Se `probabilities` não for `None`, o novo conjunto de dados é construído obtendo exemplos de uma fonte aleatória de cada vez, de acordo com as probabilidades fornecidas. O dataset resultante termina quando um dos datasets de origem esgota seus exemplos, exceto quando `oversampling` é `True`, caso em que o dataset resultante termina quando todos os datasets tiverem esgotado seus exemplos pelo menos uma vez. Observação para conjuntos de dados iteráveis: * O `num_shards` do dataset resultante é o mínimo dos `num_shards` de cada dataset para garantir um bom paralelismo. Se alguns dos seus datasets tiverem um número muito baixo de shards, você pode usar [IterableDataset.reshard()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.reshard). * Em uma configuração distribuída ou nos workers do PyTorch DataLoader, a estratégia de parada é aplicada por processo. Portanto, a estratégia "first_exhausted" em um dataset iterável particionado pode gerar menos amostras no total (até 1 amostra faltante por subconjunto de dados por worker). Exemplo: Para conjuntos de dados regulares (estilo mapa): ```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') ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/distributed.py#L10) **Parâmetros:** dataset ([Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset)) : O conjunto de dados a ser dividido por nó. rank (`int`) : Rank do nó atual. world_size (`int`) : Número total de nós. strategy (`str`, padrão `"auto"`) : Como dividir um dataset iterável. Deve ser um de `"auto"`, `"shards"` ou `"examples"`. Datasets do tipo mapa suportam apenas `"auto"`. **Retorna:** [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) O conjunto de dados a ser usado no nó com a classificação `rank`. Divida um conjunto de dados para o nó no rank `rank` em um pool de nós de tamanho `world_size`. Para conjuntos de dados no estilo mapa: Cada nó recebe um bloco de dados, por exemplo, o rank 0 recebe o primeiro bloco do conjunto de dados. Para maximizar a taxa de transferência do carregamento de dados, os blocos são compostos por dados contíguos no disco, sempre que possível. Para conjuntos de dados iteráveis: A `strategy` de divisão pode ser `"auto"`, `"shards"` ou `"examples"`: * `"shards"`: os shards são distribuídos igualmente entre os nós * `"examples"`: cada nó mantém 1 exemplo de `world_size`, pulando os outros exemplos * `"auto"` (padrão): usa `"shards"` se o conjunto de dados tiver um número de shards que seja um fator de `world_size` (ou seja, se `dataset.num_shards % world_size == 0`), que é o mais otimizado. Caso contrário, usa `"examples"`. > [!WARNING] > Se você embaralhar seu conjunto de dados iterável em um ambiente distribuído, certifique-se de definir uma `seed` fixa em [IterableDataset.shuffle()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.shuffle) portanto, a mesma lista embaralhada de shards é usada em todos os nós para saber quais shards o nó deve ignorar. #### datasets.enable_caching[[datasets.enable_caching]] ```python datasets.enable_caching() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L120) Ao aplicar transforms em um dataset, os dados são armazenados em arquivos de cache. O mecanismo de cache permite recarregar um arquivo de cache existente caso ele já tenha sido calculado. Recarregar um conjunto de dados é possível, pois os arquivos de cache são nomeados usando a impressão digital do conjunto de dados, que é atualizada após cada transformação. Se desativado, a biblioteca não recarregará mais os arquivos de datasets em cache ao aplicar transformações nos datasets. Mais precisamente, se o cache for desativado: - os arquivos de cache são sempre recriados - os arquivos de cache são gravados em um diretório temporário que é excluído quando a sessão é encerrada - os arquivos de cache são nomeados usando um hash aleatório em vez da impressão digital do conjunto de dados - Use [save_to_disk()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.save_to_disk) para salvar um dataset transformado, caso contrário ele será excluído quando a sessão for encerrada - o cache não afeta [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset). Se você deseja regenerar um dataset do zero, deve usar o parâmetro `download_mode` em [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset). #### datasets.disable_caching[[datasets.disable_caching]] ```python datasets.disable_caching() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L141) Ao aplicar transforms em um dataset, os dados são armazenados em arquivos de cache. O mecanismo de cache permite recarregar um arquivo de cache existente caso ele já tenha sido calculado. Recarregar um conjunto de dados é possível, pois os arquivos de cache são nomeados usando a impressão digital do conjunto de dados, que é atualizada após cada transformação. Se desativado, a biblioteca não recarregará mais os arquivos de datasets em cache ao aplicar transformações nos datasets. Mais precisamente, se o cache for desativado: - os arquivos de cache são sempre recriados - os arquivos de cache são gravados em um diretório temporário que é excluído quando a sessão é encerrada - os arquivos de cache são nomeados usando um hash aleatório em vez da impressão digital do conjunto de dados - Use [save_to_disk()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.save_to_disk) para salvar um dataset transformado, caso contrário ele será excluído quando a sessão for encerrada - o cache não afeta [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset). Se você deseja regenerar um dataset do zero, deve usar o parâmetro `download_mode` em [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset). #### datasets.is_caching_enabled[[datasets.is_caching_enabled]] ```python datasets.is_caching_enabled() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L162) Ao aplicar transforms em um dataset, os dados são armazenados em arquivos de cache. O mecanismo de cache permite recarregar um arquivo de cache existente caso ele já tenha sido calculado. Recarregar um conjunto de dados é possível, pois os arquivos de cache são nomeados usando a impressão digital do conjunto de dados, que é atualizada após cada transformação. Se desativado, a biblioteca não recarregará mais os arquivos de datasets em cache ao aplicar transformações nos datasets. Mais precisamente, se o cache for desativado: - os arquivos de cache são sempre recriados - os arquivos de cache são gravados em um diretório temporário que é excluído quando a sessão é encerrada - os arquivos de cache são nomeados usando um hash aleatório em vez da impressão digital do conjunto de dados - use [save_to_disk()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.save_to_disk)] para salvar um dataset transformado, caso contrário ele será excluído quando a sessão for encerrada - o cache não afeta [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset). Se você deseja regenerar um dataset do zero, deve usar o parâmetro `download_mode` em [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset). #### datasets.Column[[datasets.Column]] ```python datasets.Column(source: typing.Union[ForwardRef('Dataset'), ForwardRef('Column')], column_name: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L638) Um iterável para uma coluna específica de um [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset). Exemplo: Itere sobre os textos da coluna "text" de um dataset: ```python for text in dataset["text"]: ... ``` Ele também funciona com colunas aninhadas: ```python for source in dataset["metadata"]["source"]: ... ``` ## DatasetDict[[datasets.DatasetDict]] Dicionário com os nomes das divisões como chaves (por exemplo, 'train', 'test') e objetos `Dataset` como valores. Ele também possui métodos de transformação de dataset, como map ou filter, para processar todas as divisões de uma vez. #### datasets.DatasetDict[[datasets.DatasetDict]] [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L53) Um dicionário (dict de str: datasets.Dataset) com os métodos de transformação de datasets (map, filter, etc.) #### data[[datasets.DatasetDict.data]] ```python data() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L94) As tabelas Apache Arrow que sustentam cada divisão. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L109) Os arquivos de cache contendo a tabela Apache Arrow que sustenta cada divisão. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L127) Número de colunas em cada divisão do conjunto de dados. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L143) Número de linhas em cada divisão do conjunto de dados. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L159) Nomes das colunas em cada divisão do conjunto de dados. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L177) Formato de cada divisão do conjunto de dados (número de linhas, número de colunas). Exemplo: ```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)} ``` #### único[[datasets.DatasetDict.unique]] ```python unique(column: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L226) **Parâmetros:** column (`str`) : nome da coluna (liste todos os nomes de colunas com [column_names](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict.column_names)) **Retorna:** Dict[`str`, `list`] Dicionário de elementos únicos na coluna fornecida. Retorna uma lista dos elementos únicos em uma coluna para cada divisão. Isso é implementado no backend de baixo nível e, portanto, é muito rápido. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L250) **Retorna:** `Dict` com o número de arquivos removidos para cada split Limpe todos os arquivos de cache no diretório de cache do dataset, exceto o arquivo de cache atualmente em uso, se houver. Tenha cuidado ao executar este comando para garantir que nenhum outro processo esteja usando outros arquivos de cache. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L814) **Parâmetros:** function (`callable`) : com uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` se `batched=False` e `with_indices=False` - `function(example: Dict[str, Any], indices: int) -> Dict[str, Any]` se `batched=False` e `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` se `batched=True` e `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` se `batched=True` e `with_indices=True` Para uso avançado, a função também pode retornar um `pyarrow.Table`. Se a função for assíncrona, o `map` executará sua função em paralelo. Além disso, se sua função não retornar nada (`None`), o `map` executará sua função e retornará o dataset inalterado. Se nenhuma função for fornecida, usa-se a função identidade por padrão: `lambda x: x`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, nesse caso, a assinatura de `function` deve ser `def function(example, idx): ...`. with_rank (`bool`, padrão `False`) : Fornece o rank do processo para `function`. Observe que, nesse caso, a assinatura de `function` deve ser `def function(example[, idx], rank): ...`. with_split (`bool`, padrão `False`) : Fornece a divisão do processo para `function`. Observe que, neste caso, a assinatura de `function` deve ser `def function(example[, idx], split): ...`. input_columns (`[Union[str, list[str]]]`, *opcional*, padrão `None`) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um dicionário mapeando para todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para a `function`. batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched=True`, `batch_size <= 0` ou `batch_size == None`, forneça o conjunto de dados completo como um único lote para `function`. drop_last_batch (`bool`, padrão `False`) : Se um último lote menor que o batch_size deve ser descartado em vez de ser processado pela função. remove_columns (`[Union[str, list[str]]]`, *opcional*, padrão `None`) : Remove uma seleção de colunas durante o mapeamento. As colunas serão removidas antes de atualizar os exemplos com a saída de `function`, ou seja, se `function` estiver adicionando colunas com nomes em `remove_columns`, essas colunas serão mantidas. keep_in_memory (`bool`, padrão `False`) : Mantém o conjunto de dados em memória em vez de gravá-lo em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena o cálculo atual de `function` puder ser identificado, use-o em vez de recalcular. cache_file_names (`[Dict[str, str]]`, *opcional*, padrão `None`) : Forneça o nome de um caminho para o arquivo de cache. Ele é usado para armazenar os resultados do cálculo em vez do nome do arquivo de cache gerado automaticamente. Você deve fornecer um `cache_file_name` por conjunto de dados no dicionário de conjuntos de dados. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. features (`[datasets.Features]`, *opcional*, padrão `None`) : Use um [Features](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features) específico para armazenar o arquivo de cache em vez do gerado automaticamente. disable_nullable (`bool`, padrão `False`) : Não permite valores nulos na tabela. fn_kwargs (`Dict`, *opcional*, padrão `None`) : Argumentos de palavra-chave a serem passados para `function` num_proc (`int`, *opcional*, padrão `None`) : O número de processos a serem usados para multiprocessamento. - Se `None` ou `0`, nenhum multiprocessamento é usado e a operação é executada no processo principal. - Se for maior que `1`, um ou vários processos de trabalho são usados para processar dados em paralelo. Observação: A função passada para `map()` deve ser serializável (picklable) para que o multiprocessamento funcione corretamente (ou seja, prefira funções definidas no nível superior de um módulo, e não dentro de outra função ou classe). desc (`str`, *opcional*, padrão `None`) : Descrição significativa para ser exibida junto com a barra de progresso durante o mapeamento de exemplos. try_original_type (`Optional[bool]`, padrão `True`) : Tenta manter os tipos das colunas originais (ex.: int32 -> int32). Defina como False se quiser sempre inferir novos tipos. on_mixed_types (`Literal["use_json"]`, *opcional*, padrão `None`) : Se "use_json", use o tipo Json() para campos de tipos mistos, ou seja, campos não estruturados que contêm dados sem um esquema predefinido. Nesse caso, um campo com tipo misto é definido como Json(). Isso permite carregar listas com uma mistura de strings/inteiros/floats, por exemplo, ou dicionários com tipos de valores arbitrários. Aplica uma função a todos os exemplos da tabela (individualmente ou em lotes) e atualiza a tabela. Se a sua função retornar uma coluna que já existe, ela a sobrescreve. A transformação é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. Você pode especificar se a função deve ser processada em lote ou não com o parâmetro `batched`: - Se `False`, a função recebe 1 exemplo e deve retornar 1 exemplo. Um exemplo é um dicionário, por exemplo, `{"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 !"]}`. - Se `True` e `batch_size` é `n > 1`, a função recebe um lote de `n` exemplos como entrada e pode retornar um lote com `n` exemplos, ou com um número arbitrário de exemplos. Observe que o último lote pode ter menos de `n` exemplos. Um lote é um dicionário, por exemplo, um lote de `n` exemplos é `{"text": ["Hello there !"] * n}`. Se a função for assíncrona, `map` executará sua função em paralelo, com até mil chamadas simultâneas. É recomendável usar um `asyncio.Semaphore` na sua função se você quiser definir um número máximo de operações que podem ser executadas ao mesmo tempo. Exemplo: ```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) ``` #### filtro[[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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L986) **Parâmetros:** function (`Callable`) : Chamável com uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> bool` se `batched=False` e `with_indices=False` e `with_rank=False` - `function(example: Dict[str, Any], *extra_args) -> bool` se `batched=False` e `with_indices=True` e/ou `with_rank=True` (um argumento extra para cada) - `function(batch: Dict[str, list]) -> list[bool]` se `batched=True` e `with_indices=False` e `with_rank=False` - `function(batch: Dict[str, list], *extra_args) -> list[bool]` se `batched=True` e `with_indices=True` e/ou `with_rank=True` (um argumento extra para cada) Se nenhuma função for fornecida, o padrão é uma função que sempre retorna `True`: `lambda x: True`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, neste caso, a assinatura de `function` deve ser `def function(example, idx[, rank]): ...`. with_rank (`bool`, padrão `False`) : Fornece o rank do processo para `function`. Observe que, nesse caso, a assinatura de `function` deve ser `def function(example[, idx], rank): ...`. input_columns (`[Union[str, list[str]]]`, *opcional*, padrão `None`) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um dicionário mapeando para todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para a `function`. batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched=True` `batch_size <= 0` ou `batch_size == None` então forneça o conjunto de dados completo como um único lote para `function`. keep_in_memory (`bool`, padrão `False`) : Mantém o conjunto de dados em memória em vez de gravá-lo em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena o cálculo atual de `function` puder ser identificado, use-o em vez de recalcular. cache_file_names (`[Dict[str, str]]`, *opcional*, padrão `None`) : Forneça o nome de um caminho para o arquivo de cache. Ele é usado para armazenar os resultados do cálculo em vez do nome do arquivo de cache gerado automaticamente. Você deve fornecer um `cache_file_name` por conjunto de dados no dicionário de conjuntos de dados. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. fn_kwargs (`Dict`, *opcional*, padrão `None`) : Argumentos de palavra-chave a serem passados para `function` num_proc (`int`, *opcional*, padrão `None`) : O número de processos a serem usados para multiprocessamento. - Se `None` ou `0`, nenhum multiprocessamento é usado e a operação é executada no processo principal. - Se for maior que `1`, um ou vários processos de trabalho são usados para processar dados em paralelo. Observação: A função passada para `map()` deve ser serializável (picklable) para que o multiprocessamento funcione corretamente (ou seja, prefira funções definidas no nível superior de um módulo, e não dentro de outra função ou classe). desc (`str`, *opcional*, padrão `None`) : Descrição significativa para ser exibida junto com a barra de progresso durante o filtramento de exemplos. Aplica uma função de filtro a todos os elementos da tabela em lotes e atualiza a tabela para que o conjunto de dados inclua apenas exemplos de acordo com a função de filtro. A transformação é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1151) **Parâmetros:** column_names (`Union[str, Sequence[str]]`) : Nome(s) da(s) coluna(s) para ordenação. reverse (`Union[bool, Sequence[bool]]`, padrão `False`) : Se `True`, ordena em ordem decrescente em vez de crescente. Se um único bool for fornecido, o valor é aplicado à ordenação de todos os nomes de colunas. Caso contrário, uma lista de bools com o mesmo comprimento e ordem que column_names deve ser fornecida. null_placement (`str`, padrão `at_end`) : Coloque valores `None` no início se `at_start` ou `first` ou no final se `at_end` ou `last` keep_in_memory (`bool`, padrão `False`) : Mantém os índices ordenados na memória em vez de gravá-los em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena os índices ordenados puder ser identificado, use-o em vez de recalculá-los. indices_cache_file_names (`[Dict[str, str]]`, *opcional*, padrão `None`) : Forneça o nome de um caminho para o arquivo de cache. Ele é usado para armazenar o mapeamento de índices em vez do nome do arquivo de cache gerado automaticamente. Você deve fornecer um `cache_file_name` por conjunto de dados no dicionário de conjuntos de dados. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Um valor maior resulta em arquivos de cache menores, enquanto um valor menor consome menos memória temporária. Crie um novo conjunto de dados ordenado de acordo com uma única coluna ou múltiplas colunas. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1218) **Parâmetros:** seeds (`Dict[str, int]` ou `int`, *opcional*) : Uma seed para inicializar o BitGenerator padrão se `generator=None`. Se `None`, uma entropia fresca e imprevisível será obtida do SO. Se um `int` ou `array_like[ints]` for passado, ele será enviado ao SeedSequence para derivar o estado inicial do BitGenerator. Você pode fornecer uma `seed` por dataset no dicionário de datasets. seed (`int`, *opcional*) : Uma semente para inicializar o BitGenerator padrão se `generator=None`. Alias para seeds (um `ValueError` é lançado se ambos forem fornecidos). generators (`Dict[str, *optional*, np.random.Generator]`) : Gerador aleatório do Numpy a ser usado para calcular a permutação das linhas do conjunto de dados. Se `generator=None` (padrão), usa `np.random.default_rng` (o BitGenerator padrão (PCG64) do NumPy). Você deve fornecer um `generator` por conjunto de dados no dicionário de conjuntos de dados. keep_in_memory (`bool`, padrão `False`) : Mantém o conjunto de dados em memória em vez de gravá-lo em um arquivo de cache. load_from_cache_file (`Optional[bool]`, padrão `True` se o cache estiver habilitado) : Se um arquivo de cache que armazena o cálculo atual de `function` puder ser identificado, use-o em vez de recalcular. indices_cache_file_names (`Dict[str, str]`, *opcional*) : Forneça o nome de um caminho para o arquivo de cache. Ele é usado para armazenar os mapeamentos de índices em vez do nome do arquivo de cache gerado automaticamente. Você deve fornecer um `cache_file_name` por conjunto de dados no dicionário de conjuntos de dados. writer_batch_size (`int`, padrão `1000`) : Número de linhas por operação de escrita para o escritor de arquivo de cache. Este valor é um bom equilíbrio entre o uso de memória durante o processamento e a velocidade de processamento. Um valor maior faz com que o processamento realize menos consultas, enquanto um valor menor consome menos memória temporária durante a execução de `map`. Crie um novo Dataset em que as linhas são embaralhadas. A transformação é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. Atualmente, o shuffling usa geradores aleatórios do numpy. Você pode fornecer um NumPy BitGenerator para usar ou uma seed para iniciar o gerador aleatório padrão do NumPy (PCG64). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L571) **Parâmetros:** type (`str`, *opcional*) : Tipo de saída selecionado em `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` retorna objetos python (padrão). columns (`list[str]`, *opcional*) : Colunas a serem formatadas na saída. `None` significa que `__getitem__` retorna todas as colunas (padrão). output_all_columns (`bool`, padrão é False) : Manter também as colunas não formatadas na saída (como objetos Python), - ****format_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave passados para a função de conversão, como `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Defina o formato de retorno de `__getitem__` (tipo e colunas). O formato é definido para cada conjunto de dados no dicionário de conjuntos de dados. É possível chamar `map` depois de chamar `set_format`. Como `map` pode adicionar novas colunas, a lista de colunas formatadas é atualizada. Nesse caso, se você aplicar `map` em um dataset para adicionar uma nova coluna, essa coluna será formatada: `new formatted columns = (all columns - previously unformatted columns)` Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L622) Redefina o formato de retorno de `__getitem__` para objetos Python e todas as colunas. A transformação é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. Igual a `self.set_format()` Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L531) **Parâmetros:** type (`str`, *opcional*) : Tipo de saída selecionado em `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` retorna objetos python (padrão). columns (`list[str]`, *opcional*) : Colunas a serem formatadas na saída. `None` significa que `__getitem__` retorna todas as colunas (padrão). output_all_columns (`bool`, padrão é False) : Mantém também as colunas não formatadas na saída (como objetos Python). - ****format_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave passados para a função de conversão, como `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Para ser usado em uma declaração `with`. Define o formato de retorno de `__getitem__` (tipo e colunas). A transformação é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L683) **Parâmetros:** type (`str`, *opcional*) : Tipo de saída selecionado em `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que `__getitem__` retorna objetos python (padrão). columns (`list[str]`, *opcional*) : Colunas a serem formatadas na saída. `None` significa que `__getitem__` retorna todas as colunas (padrão). output_all_columns (`bool`, padrão `False`) : Mantém também as colunas não formatadas na saída (como objetos Python). - ****format_kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave passados para a função de conversão, como `np.array`, `torch.tensor` ou `tensorflow.ragged.constant`. Defina o formato de retorno de `__getitem__` (tipo e colunas). O formatação dos dados é aplicada em tempo real. O formato `type` (por exemplo, "numpy") é usado para formatar lotes ao usar `__getitem__`. O formato é definido para cada conjunto de dados no dicionário de conjuntos de dados. Também é possível usar transforms personalizados para formatação usando [with_transform()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.with_transform). Ao contrário de [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict.set_format), `with_format` retorna um novo objeto [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) com novos objetos [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L760) **Parâmetros:** transform (`Callable`, *opcional*) : Transformação de formatação definida pelo usuário, substitui o formato definido por [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format). Uma função de formatação é um chamável que recebe um lote (como um dict) como entrada e retorna um lote. Esta função é aplicada imediatamente antes de retornar os objetos em `__getitem__`. columns (`list[str]`, *opcional*) : Colunas a serem formatadas na saída. Se especificado, o lote de entrada da transformação contém apenas essas colunas. output_all_columns (`bool`, padrão é False) : Mantém também as colunas não formatadas na saída (como objetos Python). Se definido como `True`, as outras colunas não formatadas são mantidas junto com a saída da transformação. Defina o formato de retorno de `__getitem__` usando esta transformação. A transformação é aplicada em tempo real nos lotes quando `__getitem__` é chamado. A transformação é definida para cada conjunto de dados no dicionário de conjuntos de dados Assim como [set_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.set_format), isso pode ser redefinido usando [reset_format()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.reset_format). Ao contrário de `set_transform()`, `with_transform` retorna um novo objeto [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) com novos objetos [Dataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L193) Achate a Tabela Apache Arrow de cada split (os recursos aninhados são achatados). Cada coluna com tipo struct é achatada em uma coluna por campo do struct. As outras colunas permanecem inalteradas. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L274) **Parâmetros:** features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features)) : Novos recursos para os quais o conjunto de dados será convertido. O nome e a ordem dos campos nos recursos devem corresponder aos nomes atuais das colunas. O tipo dos dados também deve ser convertível de um tipo para o outro. Para conversões não triviais, por exemplo, `string` <-> `ClassLabel`, você deve usar [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict.map) para atualizar o conjunto de dados. Faça o cast do dataset para um novo conjunto de recursos. A transformação é aplicada a todos os datasets do dicionário de datasets. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L306) **Parâmetros:** column (`str`) : Nome da coluna. feature (`Feature`) : Recurso alvo. **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Convert a coluna para recurso para decodificação. Exemplo: ```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]]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L335) **Parâmetros:** column_names (`Union[str, list[str]]`) : Nome da(s) coluna(s) a ser(em) removida(s). **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Uma cópia do objeto de dataset sem as colunas a serem removidas. Remove uma ou várias colunas de cada divisão do conjunto de dados e os recursos associados às colunas. A transformação é aplicada a todas as divisões do dicionário do conjunto de dados. Você também pode remover uma coluna usando [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict.map) com `remove_columns`, mas o método presente não copia os dados das colunas restantes e, portanto, é mais rápido. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L377) **Parâmetros:** original_column_name (`str`) : Nome da coluna a ser renomeada. new_column_name (`str`) : Novo nome para a coluna. Renomeia uma coluna no dataset e move os recursos associados à coluna original para o novo nome da coluna. A transformação é aplicada a todos os datasets do dicionário de datasets. Você também pode renomear uma coluna usando [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict.map) com `remove_columns`, mas o método presente: - cuida de mover os recursos originais para o novo nome de coluna. - não copia os dados para um novo dataset e, portanto, é muito mais rápido. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L425) **Parâmetros:** column_mapping (`Dict[str, str]`) : Um mapeamento de colunas para renomear para seus novos nomes. **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Uma cópia do conjunto de dados com as colunas renomeadas. Renomeie várias colunas no conjunto de dados e mova os recursos associados às colunas originais para os novos nomes de colunas. A transformação é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. Exemplo: ```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]]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L463) **Parâmetros:** column_names (`Union[str, list[str]]`) : Nome da(s) coluna(s) a ser(em) mantida(s). Selecione uma ou várias colunas de cada divisão no conjunto de dados e os recursos associados às colunas. A transformação é aplicada a todas as divisões do dicionário do conjunto de dados. Exemplo: ```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 }) }) ``` #### class_encode_column[[datasets.DatasetDict.class_encode_column]] ```python class_encode_column(column: str, include_nulls: bool = False) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L499) **Parâmetros:** column (`str`) : O nome da coluna para a qual o cast será aplicado. include_nulls (`bool`, padrão `False`) : Se deve incluir valores nulos nos rótulos de classe. Se `True`, os valores nulos serão codificados como o rótulo de classe `"None"`. Converte a coluna indicada em [ClassLabel](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.ClassLabel) e atualiza as tabelas. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1623) **Parâmetros:** repo_id (`str`) : O ID do repositório para o qual será feito o push, no seguinte formato: `/` ou `/`. Também aceita ``, que usará o namespace do usuário conectado por padrão. Também pode ser um local dentro de um bucket, por exemplo, `buckets///...` config_name (`str`) : Nome da configuração de um conjunto de dados. O padrão é "default". set_default (`bool`, *opcional*) : Se deve definir esta configuração como a padrão. Caso contrário, a configuração padrão é a nomeada "default". data_dir (`str`, *opcional*) : Nome do diretório que conterá os arquivos de dados enviados. O padrão é `config_name` se for diferente de "default", caso contrário, "data". commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O padrão será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descrição do commit que será criado. Além disso, descrição da PR, caso uma PR seja criada (`create_pr` é True). private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir. token (`str`, *opcional*) : Um token de autenticação opcional para o Hugging Face Hub. Se nenhum token for passado, será usado o token salvo localmente ao fazer login com `hf auth login`. Será gerado um erro se nenhum token for passado e o usuário não estiver conectado. revision (`str`, *opcional*) : Branch para o qual os arquivos enviados serão enviados. O padrão é a branch `"main"`. create_pr (`bool`, *opcional*, padrão `False`) : Se deve criar um PR com os arquivos enviados ou fazer o commit diretamente. max_shard_size (`int` ou `str`, *opcional*, padrão `"500MB"`) : O tamanho máximo dos shards do dataset a serem enviados para o hub. Se expresso como uma string, precisa ser dígitos seguidos por uma unidade (como `"500MB"` ou `"1GB"`). num_shards (`Dict[str, int]`, *opcional*) : Número de shards a serem gravados. Por padrão, o número de shards depende de `max_shard_size`. Use um dicionário para definir um num_shards diferente para cada split. embed_external_files (`bool`, padrão `True`) : Se deve incorporar os bytes dos arquivos nos shards. Em particular, isso fará o seguinte antes do push para os campos do tipo: - [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) e [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image) remove as informações de caminho local e incorpora o conteúdo do arquivo nos arquivos Parquet. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao preparar e enviar o dataset. Isso é útil se o dataset for composto por muitas amostras ou arquivos de mídia para incorporar. Usa o contexto "spawn" para funcionar com hf_xet, o cliente rust para uploads rápidos para o HF. O multiprocessing é desabilitado por padrão. **Retorna:** huggingface_hub.CommitInfo Envia o [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) para o hub como um dataset Parquet. O [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) é enviado usando requisições HTTP e não requer a instalação de git ou git-lfs. Cada divisão do conjunto de dados será enviada de forma independente. O conjunto de dados enviado manterá os nomes originais das divisões. Os arquivos Parquet resultantes são autossuficientes por padrão: se o seu conjunto de dados contiver dados de [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image) ou [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio), os arquivos Parquet armazenarão os bytes das suas imagens ou arquivos de áudio. Você pode desativar isso definindo `embed_external_files` como False. Exemplo: ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Se você deseja adicionar uma nova configuração (ou subconjunto) a um conjunto de dados (por exemplo, se o conjunto de dados tiver várias tarefas/versões/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1301) **Parâmetros:** dataset_dict_path (`path-like`) : Path (por exemplo, `dataset/train`) ou URI remoto (por exemplo, `s3://my-bucket/dataset/train`) do diretório do dataset dict onde o dataset dict será salvo. max_shard_size (`int` ou `str`, *opcional*, padrão `"500MB"`) : O tamanho máximo dos shards do dataset a serem salvos no sistema de arquivos. Se expresso como uma string, precisa ser dígitos seguidos por uma unidade (como `"50MB"`). num_shards (`Dict[str, int]`, *opcional*) : Número de shards a serem gravados. Por padrão, o número de shards depende de `max_shard_size` e `num_proc`. Você precisa fornecer o número de shards para cada conjunto de dados no dicionário de conjuntos de dados. Use um dicionário para definir um num_shards diferente para cada split. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao baixar e gerar o dataset localmente. O multiprocessing é desabilitado por padrão. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. Salva um dicionário de dataset em um sistema de arquivos usando `fsspec.spec.AbstractFileSystem`. Para dados de [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) e [Video](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Video): Todos os dados de Image(), Audio() e Video() são armazenados nos arquivos arrow. Se você deseja armazenar caminhos ou urls, use o tipo Value("string"). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1375) **Parâmetros:** dataset_dict_path (`path-like`) : Path (por exemplo, `"dataset/train"`) ou URI remoto (por exemplo, `"s3//my-bucket/dataset/train"`) do diretório do dataset dict de onde o dataset dict será carregado. keep_in_memory (`bool`, padrão `None`) : Se deve copiar o dataset em memória. Se `None`, o dataset não será copiado em memória, a menos que seja explicitamente habilitado ao definir `datasets.config.IN_MEMORY_MAX_SIZE` para um valor diferente de zero. Veja mais detalhes na seção [melhorar o desempenho](../cache#improve-performance). storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Carregue um conjunto de dados que foi salvo anteriormente usando `save_to_disk` de um sistema de arquivos usando `fsspec.spec.AbstractFileSystem`. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1435) **Parâmetros:** path_or_paths (`dict` de caminho(s) como objeto) : Caminho(s) do(s) arquivo(s) CSV. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (str, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `pandas.read_csv`. **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Crie um [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) a partir de arquivo(s) CSV. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1478) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) JSON Lines. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (str, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `JsonConfig`. **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Crie um [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) a partir de arquivo(s) JSON Lines. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1521) **Parâmetros:** path_or_paths (`dict` de caminho(s) como objeto) : Caminho(s) do(s) arquivo(s) CSV. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. columns (`list[str]`, *opcional*) : Se não for `None`, apenas essas colunas serão lidas do arquivo. O nome de uma coluna pode ser um prefixo de um campo aninhado, por exemplo, 'a' selecionará 'a.b', 'a.c' e 'a.d.e'. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `ParquetConfig`. **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Crie um [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) a partir de arquivo(s) Parquet. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1570) **Parâmetros:** path_or_paths (`dict` de caminho(s) como objeto) : Caminho(s) do(s) arquivo(s) de texto. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. cache_dir (`str`, *opcional*, padrão `"~/.cache/huggingface/datasets"`) : Diretório para armazenar os dados em cache. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `TextConfig`. **Retorna:** [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) Crie um [DatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetDict) a partir de arquivo(s) de texto. Exemplo: ```py >>> from datasets import DatasetDict >>> ds = DatasetDict.from_text({'train': 'path/to/dataset.txt'}) ``` ## IterableDataset[[datasets.IterableDataset]] A classe base [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) implementa um Dataset iterável baseado em geradores 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2690) Um Dataset baseado em um iterável. #### from_file[[datasets.IterableDataset.from_file]] ```python from_file(filename: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3188) **Parâmetros:** filename (`str`) : Nome do arquivo do conjunto de dados. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Instanciar um IterableDataset a partir de uma tabela Arrow no arquivo filename. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3204) **Parâmetros:** df (`pandas.DataFrame`) : Dataframe que contém o conjunto de dados. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. info (`DatasetInfo`, *opcional*) : Informações do dataset, como descrição, citação, etc. split (`NamedSplit`, *opcional*) : Nome da divisão do conjunto de dados. preserve_index (`bool`, *opcional*) : Se deve armazenar o índice como uma coluna adicional no Dataset resultante. O valor padrão de `None` armazenará o índice como uma coluna, exceto para `RangeIndex`, que é armazenado apenas como metadados. Use `preserve_index=True` para forçar que ele seja armazenado como uma coluna. num_shards (`int`, padrão `1`) : Número de shards a definir ao instanciar o dataset iterável. Isso é especialmente útil para datasets grandes, permitindo embaralhar corretamente e também habilitar o carregamento paralelo rápido usando um PyTorch DataLoader ou em configurações distribuídas, por exemplo. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Converta um `pandas.DataFrame` para uma `pyarrow.Table` para criar um [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset). Os tipos de coluna na Tabela Arrow resultante são inferidos a partir dos dtypes das `pandas.Series` no DataFrame. No caso de Series não-object, o dtype do NumPy é traduzido para seu equivalente no Arrow. No caso de `object`, precisamos inferir o tipo de dados examinando os objetos Python presentes nesta Series. Observe que Series do dtype `object` não carregam informações suficientes para sempre levar a um tipo Arrow significativo. No caso em que não podemos inferir um tipo, por exemplo, porque o DataFrame tem comprimento 0 ou a Series contém apenas objetos `None/nan`, o tipo é definido como `null`. Esse comportamento pode ser evitado construindo features explícitas e passando-as para esta função. Importante: um dataset criado com from_pandas() fica na memória. Isso pode mudar no futuro, mas, por enquanto, se você quiser reduzir o uso de memória, deve gravá-lo em disco e recarregá-lo usando, por exemplo, to_parquet / from_parquet. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3316) **Parâmetros:** mapping (`Mapping`) : Mapeamento de strings para Arrays ou listas Python. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. info (`DatasetInfo`, *opcional*) : Informações do dataset, como descrição, citação, etc. split (`NamedSplit`, *opcional*) : Nome da divisão do conjunto de dados. num_shards (`int`, padrão `1`) : Número de shards a definir ao instanciar o dataset iterável. Isso é especialmente útil para datasets grandes, permitindo embaralhar corretamente e também habilitar o carregamento paralelo rápido usando um PyTorch DataLoader ou em configurações distribuídas, por exemplo. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Converta `dict` para uma `pyarrow.Table` para criar um [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset). Importante: um dataset criado com from_dict() fica na memória. Isso pode mudar no futuro, mas, por enquanto, se você quiser reduzir o uso de memória, deve gravá-lo novamente em disco e recarregá-lo usando, por exemplo, 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3353) **Parâmetros:** mapping (`List[dict]`) : Uma lista de mapeamentos de strings para valores de linha. features (`Features`, opcional) : Recursos do conjunto de dados. info (`DatasetInfo`, opcional) : Informações do conjunto de dados, como descrição, citação, etc. split (`NamedSplit`, opcional) : Nome da divisão do conjunto de dados. num_shards (`int`, padrão `1`) : Número de shards a definir ao instanciar o dataset iterável. Isso é especialmente útil para datasets grandes, permitindo embaralhar corretamente e também habilitar o carregamento paralelo rápido usando um PyTorch DataLoader ou em configurações distribuídas, por exemplo. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Converta uma lista de dicts para uma `pyarrow.Table` para criar um [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset)`. Observe que as chaves da primeira entrada serão usadas para determinar as colunas do conjunto de dados, independentemente do que for passado para features. Importante: um dataset criado com from_list() fica em memória. Isso pode mudar no futuro, mas, por enquanto, se você quiser reduzir o uso de memória, deve gravá-lo novamente em disco e recarregá-lo usando, por exemplo, 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')) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3090) **Parâmetros:** generator (`Callable`) : Uma função geradora que `yields` exemplos. features (`Features`, *opcional*) : Recursos do conjunto de dados. gen_kwargs(`dict`, *opcional*) : Argumentos de palavra-chave a serem passados para o chamável `generator`. Você pode definir um conjunto de dados iterável fragmentado passando a lista de fragmentos em `gen_kwargs`. Isso pode ser usado para melhorar o embaralhamento e ao iterar sobre o conjunto de dados com múltiplos workers. split ([NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit), padrão `Split.TRAIN`) : Nome da divisão a ser atribuído ao conjunto de dados. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Crie um Dataset Iterável a partir de um gerador. Exemplo: ```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]]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4343) **Parâmetros:** column_names (`Union[str, List[str]]`) : Nome da(s) coluna(s) a ser(em) removida(s). **Retorna:** `IterableDataset` Uma cópia do objeto de dataset sem as colunas a serem removidas. Remove uma ou várias colunas do dataset e os recursos associados a elas. A remoção é feita em tempo de execução nos exemplos ao iterar sobre o dataset. Exemplo: ```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]]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4378) **Parâmetros:** column_names (`Union[str, List[str]]`) : Nome da(s) coluna(s) a ser(em) selecionada(s). **Retorna:** `IterableDataset` Uma cópia do objeto de conjunto de dados com as colunas selecionadas. Selecione uma ou várias colunas no conjunto de dados e os recursos associados a elas. A seleção é feita em tempo real nos exemplos ao iterar sobre o conjunto de dados. Exemplo: ```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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4428) **Parâmetros:** column (`str`) : Nome da coluna. feature (`Feature`) : Recurso alvo. **Retorna:** `IterableDataset` Convert a coluna para recurso para decodificação. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4474) **Parâmetros:** features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features)) : Novos recursos para os quais o conjunto de dados será convertido. Os nomes dos campos nos recursos devem corresponder aos nomes atuais das colunas. O tipo dos dados também deve ser convertível de um tipo para o outro. Para conversões não triviais, por exemplo, `string` <-> `ClassLabel`, você deve usar [map()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Dataset.map) para atualizar o Dataset. **Retorna:** `IterableDataset` Uma cópia do conjunto de dados com recursos convertidos. Convert o conjunto de dados para um novo conjunto de recursos. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4520) **Parâmetros:** enable (`bool`, padrão `True`) : Ativa ou desativa a decodificação de recursos. num_threads (`int`, *opcional*, padrão `None`) : Ativa a multithreading para a decodificação de features. Observe que [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset) já usa algumas threads por padrão ao transmitir um dataset no HF com features decodificáveis. Por padrão, `num_threads` é definido como 32 se pelo menos uma feature exigir decodificação, e 0 caso contrário. **Retorna:** `IterableDataset` Uma cópia do conjunto de dados com recursos convertidos. Ative ou desative a decodificação dos recursos do conjunto de dados para áudio, imagem e vídeo. Quando habilitado (padrão), os tipos de mídia são decodificados: * áudio -> dicionário de "array" e "sampling_rate" e "path" * imagem -> PIL.Image * video -> torchcodec.decoders.VideoDecoder O multithreading pode ser habilitado com `num_threads`: cada arquivo de mídia é então lido e decodificado em uma thread de worker, de modo que as viagens de rede de exemplos consecutivos se sobrepõem. Isso é especialmente útil para acelerar o streaming de dados remotos, e [load_dataset()](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.load_dataset) já o habilita por padrão ao fazer streaming de um dataset remoto que possui recursos decodificáveis (veja `HF_DATASETS_DECODE_NUM_THREADS`). Datasets lidos do disco local são transmitidos com `num_threads=0`, pois o multithreading pode ser mais lento do que a decodificação na thread principal para dados locais em discos rápidos. Como os exemplos são decodificados com antecedência, cada thread em execução pode manter um exemplo na memória: reduza `num_threads` para usar menos memória. Desabilitar a decodificação é útil se você deseja iterar sobre os caminhos ou bytes dos arquivos de mídia sem decodificar seu conteúdo. Para desabilitar a decodificação, você pode usar `.decode(False)`, que é equivalente a chamar `.cast()` ou `.cast_column()` com todos os tipos Audio, Image e Video definidos como `decode=False`. Exemplos: Desativar a decodificação: ```py >>> from datasets import load_dataset >>> ds = load_dataset("sshh12/planet-textures", split="train", streaming=True) >>> next(iter(ds)) {'image': , '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.' } ``` Acelere o streaming com multithreading: ```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__() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3035) #### iter[[datasets.IterableDataset.iter]] ```python iter(batch_size: int, drop_last_batch: bool = False) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3056) **Parâmetros:** batch_size (`int`) : tamanho de cada lote a ser gerado. drop_last_batch (`bool`, padrão *False*) : Se um último lote menor que o batch_size deve ser descartado Itere pelos lotes de tamanho *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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3676) **Parâmetros:** function (`Callable`, *opcional*, padrão `None`) : Função aplicada em tempo real nos exemplos ao iterar pelo dataset. Ela deve ter uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` se `batched=False` e `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` se `batched=False` e `with_indices=True` - `function(batch: Dict[str, List]) -> Dict[str, List]` se `batched=True` e `with_indices=False` - `function(batch: Dict[str, List], indices: List[int]) -> Dict[str, List]` se `batched=True` e `with_indices=True` Para uso avançado, a função também pode retornar um `pyarrow.Table`. Se a função for assíncrona, o `map` executará sua função em paralelo. Além disso, se sua função não retornar nada (`None`), o `map` executará sua função e retornará o dataset inalterado. Se nenhuma função for fornecida, usa-se a função identidade por padrão: `lambda x: x`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, neste caso, a assinatura de `function` deve ser `def function(example, idx[, rank]): ...`. input_columns (`Optional[Union[str, List[str]]]`, padrão `None`) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um dicionário mapeando todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para a `function`. batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched=True`. Se `batch_size <= 0` ou `batch_size == None`, o conjunto de dados completo é fornecido como um único lote para `function`. drop_last_batch (`bool`, padrão `False`) : Se um último lote menor que o batch_size deve ser descartado em vez de ser processado pela função. remove_columns (`[List[str]]`, *opcional*, padrão `None`) : Remove uma seleção de colunas durante o mapeamento. As colunas serão removidas antes de atualizar os exemplos com a saída de `function`, ou seja, se `function` estiver adicionando colunas com nomes em `remove_columns`, essas colunas serão mantidas. features (`[Features]`, *opcional*, padrão `None`) : Tipos de recursos do dataset resultante. fn_kwargs (`Dict`, *opcional*, padrão `None`) : Argumentos de palavra-chave a serem passados para `function`. Aplica uma função a todos os exemplos no dataset iterável (individualmente ou em lotes) e os atualiza. Se sua função retornar uma coluna que já existe, ela a sobrescreve. A função é aplicada em tempo real nos exemplos ao iterar sobre o dataset. Você pode especificar se a função deve ser processada em lote ou não com o parâmetro `batched`: - Se `False`, a função recebe 1 exemplo e deve retornar 1 exemplo. Um exemplo é um dicionário, por exemplo, `{"text": "Hello there !"}`. - Se `True` e `batch_size` for 1, a função recebe um lote com 1 exemplo como entrada e pode retornar um lote com 1 ou mais exemplos. Um lote é um dicionário, por exemplo, um lote com 1 exemplo é {"text": ["Hello there !"]}. - Se `True` e `batch_size` é `n` > 1, a função recebe um lote de `n` exemplos como entrada e pode retornar um lote com `n` exemplos, ou com um número arbitrário de exemplos. Observe que o último lote pode ter menos de `n` exemplos. Um lote é um dicionário, por exemplo, um lote de `n` exemplos é `{"text": ["Hello there !"] * n}`. Se a função for assíncrona, `map` executará sua função em paralelo, com até mil chamadas simultâneas. É recomendável usar um `asyncio.Semaphore` na sua função se você quiser definir um número máximo de operações que podem ser executadas ao mesmo tempo. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4288) **Parâmetros:** original_column_name (`str`) : Nome da coluna a ser renomeada. new_column_name (`str`) : Novo nome para a coluna. **Retorna:** `IterableDataset` Uma cópia do conjunto de dados com uma coluna renomeada. Renomeie uma coluna no dataset e mova os recursos associados à coluna original para o novo nome da coluna. Exemplo: ```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 .'} ``` #### filtro[[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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3858) **Parâmetros:** function (`Callable`) : Chamável com uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> bool` se `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` se `with_indices=True, batched=False` - `function(example: Dict[str, List]) -> List[bool]` se `with_indices=False, batched=True` - `function(example: Dict[str, List], indices: List[int]) -> List[bool]` se `with_indices=True, batched=True` Se a função for assíncrona, o `filter` executará sua função em paralelo. Se nenhuma função for fornecida, o padrão é uma função que sempre retorna True: `lambda x: True`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, nesse caso, a assinatura de `function` deve ser `def function(example, idx): ...`. input_columns (`str` ou `List[str]`, *opcional*) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um dicionário mapeando para todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para a `function`. batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched=True`. fn_kwargs (`Dict`, *opcional*, padrão `None`) : Argumentos de palavra-chave a serem passados para `function`. Aplicar uma função de filtro a todos os elementos para que o conjunto de dados inclua apenas exemplos de acordo com a função de filtro. O filtramento é feito em tempo real ao iterar sobre o conjunto de dados. Se a função for assíncrona, `filter` executará sua função em paralelo, com até mil chamadas simultâneas (configurável). É recomendável usar um `asyncio.Semaphore` na sua função se você quiser definir um número máximo de operações que podem ser executadas ao mesmo tempo. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3961) **Parâmetros:** seed (`int`, *opcional*, padrão `None`) : Semente aleatória que será usada para embaralhar o conjunto de dados. É usada para amostrar do buffer de embaralhamento e também para embaralhar os fragmentos de dados. generator (`numpy.random.Generator`, *opcional*) : Gerador aleatório do Numpy a ser usado para calcular a permutação das linhas do conjunto de dados. Se `generator=None` (padrão), usa `np.random.default_rng` (o BitGenerator padrão (PCG64) do NumPy). buffer_size (`int`, padrão `1000`) : Tamanho do buffer. max_buffer_input_shards (`int`, padrão `10`) : Número máximo de shards a serem usados para alimentar o buffer de uma vez. Embaralha aleatoriamente os elementos deste conjunto de dados. Este conjunto de dados preenche um buffer com `buffer_size` elementos e, em seguida, amostra aleatoriamente elementos deste buffer, substituindo os elementos selecionados por novos elementos. Para uma embaralhamento perfeito, é necessário um tamanho de buffer maior ou igual ao tamanho total do conjunto de dados. Por exemplo, se o seu conjunto de dados contém 10.000 elementos, mas `buffer_size` está definido como 1000, então `shuffle` inicialmente selecionará um elemento aleatório apenas dos primeiros 1000 elementos no buffer. Assim que um elemento é selecionado, seu espaço no buffer é substituído pelo próximo (ou seja, o 1.001º) elemento, mantendo o buffer de 1000 elementos. Se o conjunto de dados é composto por vários shards, ele preenche o buffer usando até `max_buffer_input_shards` shards por vez e também embaralha a ordem dos shards. Isso melhora significativamente a qualidade do embaralhamento. Os shards de entrada são intercalados dentro de cada nó e worker, preservando o número de shards disponíveis para carregamento paralelo de dados. No entanto, se a ordem tiver sido fixada usando [skip()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.skip) ou [take()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.take), a ordem dos shards permanece inalterada e apenas um shard por vez é usado para preencher o buffer. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4657) **Parâmetros:** batch_size (`int`, opcional) : O número de amostras em cada lote. by_column (`Union[str, list[str]`, opcional) : A coluna usada para agrupar exemplos em lotes. Exemplos sucessivos com o mesmo valor para essa coluna são agrupados no mesmo lote. Isso também pode ser uma lista de colunas, se você quiser agrupar por múltiplas colunas. Ao agrupar por coluna, o batch_size é usado apenas para controlar o tamanho dos lotes a serem agrupados ou fatiados durante a acumulação. drop_last_batch (`bool`, padrão `False`) : Se deve descartar o último lote incompleto. Agrupe as amostras do conjunto de dados em lotes. Exemplo: Tamanho de lote fixo: ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(batch_size=32) ``` Lotes de amostras sucessivas com valor idêntico para "my_column": ```py >>> ds = load_dataset("some_dataset", streaming=True, split="train") >>> batched_ds = ds.batch(by_column="my_column") ``` #### pular[[datasets.IterableDataset.skip]] ```python skip(n: int) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4058) **Parâmetros:** n (`int`) : Número de elementos a serem ignorados. Crie um novo [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) que ignora os primeiros `n` elementos. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4144) **Parâmetros:** n (`int`) : Número de elementos a serem obtidos. Crie um novo [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) com apenas os primeiros `n` elementos. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4179) **Parâmetros:** num_shards (`int`) : Quantos shards dividir o dataset. index (`int`) : Qual shard selecionar e retornar. contiguous : (`bool`, padrão `True`): Se deve selecionar blocos contíguos de índices para os shards. Retorna o shard de índice `index` do conjunto de dados dividido em `num_shards` partes. Isso faz o particionamento de forma determinística. `dataset.shard(n, i)` divide o conjunto de dados em blocos contíguos, de modo que ele possa ser facilmente concatenado novamente após o processamento. Se `dataset.num_shards % n == l`, então os primeiros `l` conjuntos de dados têm cada um `(dataset.num_shards // n) + 1` shards, e os conjuntos de dados restantes têm `(dataset.num_shards // n)` shards. `datasets.concatenate_datasets([dset.shard(n, i) for i in range(n)])` retorna um conjunto de dados com a mesma ordem que o original. Em particular, `dataset.shard(dataset.num_shards, i)` retorna um conjunto de dados com 1 shard. Nota: n deve ser menor ou igual ao número de shards no dataset `dataset.num_shards`. Por outro lado, `dataset.shard(n, i, contiguous=False)` contém todos os shards do dataset cujo índice mod `n = i`. Certifique-se de fazer o sharding antes de usar qualquer operador de randomização (como `shuffle`). O ideal é que o operador de sharding seja usado no início do pipeline do dataset. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4235) Reorganize o conjunto de dados, se possível, ou seja, divida os shards atuais em mais shards. Isso aumenta o número de shards e o conjunto de dados resultante terá num_shards >= previous_num_shards. A igualdade pode ocorrer se nenhum shard puder ser dividido ainda mais. O mecanismo de resharding depende do formato do arquivo do conjunto de dados: * Parquet: dividir em shards por grupo de linhas em vez de por arquivo * Vortex: shard por intervalo de chunks consecutivos (cada um com cerca de 64MB de dados do arquivo) em vez de por arquivo * Outros: ainda não implementado (contribuições são bem-vindas!) Certifique-se de redividir/dividir antes de usar qualquer operador de randomização (como `shuffle`). O ideal é que o operador de divisão seja usado no início do pipeline do conjunto de dados. Exemplo: ```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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4100) **Parâmetros:** num_times (`int`) ou (`None`) : Número de vezes para repetir o conjunto de dados. Se `None`, o conjunto de dados será repetido indefinidamente. Crie um novo [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) que repete o dataset subjacente `num_times` vezes. Uma entrada vazia encerra o processo mesmo quando `num_times` é `None`. Obs. O efeito de chamar shuffle após repeat depende significativamente do tamanho do buffer. Com buffer_size 1, dados duplicados nunca são vistos na mesma iteração, mesmo após a embaralhamento: ds.repeat(n).shuffle(seed=42, buffer_size=1) é equivalente a ds.shuffle(seed=42, buffer_size=1).repeat(n), e apenas embaralha a ordem dos shards dentro de cada iteração. Com tamanho de buffer >= (número de amostras no conjunto de dados * num_times), obtemos embaralhamento completo dos dados repetidos, ou seja, podemos observar duplicatas na mesma iteração. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4856) **Parâmetros:** path_or_buf (`PathLike` ou `FileOrBuffer`) : Um caminho para um arquivo (por exemplo, `file.csv`), um URI remoto (por exemplo, `hf://datasets/username/my_dataset_name/data.csv`) ou um BinaryIO, onde o conjunto de dados será salvo no formato especificado. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. - ****to_csv_kwargs** (argumentos de palavra-chave adicionais): Parâmetros para passar ao [`pandas.DataFrame.to_csv`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_csv.html) do pandas. O parâmetro `index` tem o valor padrão `False` se não for especificado. Se você deseja gravar o índice, passe `index=True` e também defina um nome para a coluna de índice passando `index_label`. **Retorna:** `int` O número de caracteres ou bytes gravados. Exporta o conjunto de dados para csv. Isso itera sobre o conjunto de dados e o carrega completamente na memória antes de gravá-lo. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4777) **Parâmetros:** batch_size (`int`, *opcional*) : O tamanho (número de linhas) dos lotes se `batched` for `True`. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. batched (`bool`) : Defina como `True` para retornar um gerador que produz o conjunto de dados em lotes de `batch_size` linhas. O valor padrão é `False` (retorna todo o conjunto de dados de uma vez). **Retorna:** `pandas.DataFrame` ou `Iterator[pandas.DataFrame]` Retorna o conjunto de dados como um `pandas.DataFrame`. Também pode retornar um gerador para conjuntos de dados grandes. Exemplo: ```py >>> ds.to_pandas() ``` #### to_dict[[datasets.IterableDataset.to_dict]] ```python to_dict(batch_size: typing.Optional[int] = None, batched: bool = False) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4737) **Parâmetros:** batch_size (`int`, *opcional*) : O tamanho (número de linhas) dos lotes se `batched` for `True`. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. **Retorna:** `dict` ou `Iterator[dict]` Retorna o conjunto de dados como um dicionário Python. Também pode retornar um gerador para conjuntos de dados grandes. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4899) **Parâmetros:** path_or_buf (`PathLike` ou `FileOrBuffer`) : Um caminho para um arquivo (por exemplo, `file.json`), um URI remoto (por exemplo, `hf://datasets/username/my_dataset_name/data.json`) ou um BinaryIO, onde o conjunto de dados será salvo no formato especificado. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. - ****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`. **Retorna:** `int` O número de caracteres ou bytes gravados. Exporte o conjunto de dados para JSON Lines ou JSON. Isso itera sobre o conjunto de dados e o carrega completamente na memória antes de gravá-lo. O formato de saída padrão é [JSON Lines](https://jsonlines.org/). Para exportar para [JSON](https://www.json.org), passe o argumento `lines=False` e o `orient` desejado. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4995) **Parâmetros:** path_or_buf (`PathLike` ou `FileOrBuffer`) : Um caminho para um arquivo (por exemplo, `file.parquet`), um URI remoto (por exemplo, `hf://datasets/username/my_dataset_name/data.parquet`) ou um BinaryIO, onde o conjunto de dados será salvo no formato especificado. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. storage_options (`dict`, *opcional*) : Pares de chave/valor a serem passados para o backend do sistema de arquivos, se houver. - ****parquet_writer_kwargs** (argumentos de palavra-chave adicionais) : Parâmetros para passar ao `pyarrow.parquet.ParquetWriter` do PyArrow. **Retorna:** `int` O número de caracteres ou bytes gravados. Exporta o conjunto de dados para parquet Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L4953) **Parâmetros:** name (`str`) : Nome da tabela SQL. con (`str` ou `sqlite3.Connection` ou `sqlalchemy.engine.Connection` ou `sqlalchemy.engine.Connection`) : Uma [string URI](https://docs.sqlalchemy.org/en/13/core/engines.html#database-urls) ou um objeto de conexão SQLite3/SQLAlchemy usado para gravar em um banco de dados. batch_size (`int`, *opcional*) : Tamanho do lote a ser carregado na memória e escrito de uma vez. O padrão é `datasets.config.DEFAULT_MAX_BATCH_SIZE`. - ****sql_writer_kwargs** (argumentos de palavra-chave adicionais) : Parâmetros para passar ao [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.to_sql.html) do pandas. O parâmetro `index` tem o valor padrão `False` se não for especificado. Se você deseja gravar o índice, passe `index=True` e também defina um nome para a coluna de índice passando `index_label`. **Retorna:** `int` O número de registros gravados. Exporta o conjunto de dados para um banco de dados SQL. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L5330) **Parâmetros:** repo_id (`str`) : O ID do repositório para o qual será feito o push, no seguinte formato: `/` ou `/`. Também aceita ``, que usará o namespace do usuário conectado por padrão. Também pode ser um local dentro de um bucket, por exemplo, `buckets///...` config_name (`str`, padrão "default") : O nome da configuração (ou subconjunto) de um conjunto de dados. Padrão é "default". set_default (`bool`, *opcional*) : Se deve definir esta configuração como a padrão. Caso contrário, a configuração padrão é a nomeada "default". split (`str`, *opcional*) : O nome da divisão que será atribuído a esse conjunto de dados. O padrão é `self.split`. data_dir (`str`, *opcional*) : Nome do diretório que conterá os arquivos de dados enviados. O padrão é `config_name` se for diferente de "default", caso contrário, "data". commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O padrão será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descrição do commit que será criado. Além disso, descrição da PR, caso uma PR seja criada (`create_pr` é True). private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir. token (`str`, *opcional*) : Um token de autenticação opcional para o Hugging Face Hub. Se nenhum token for passado, será usado o token salvo localmente ao fazer login com `hf auth login`. Será gerado um erro se nenhum token for passado e o usuário não estiver conectado. revision (`str`, *opcional*) : Branch para o qual os arquivos enviados serão enviados. O padrão é a branch `"main"`. create_pr (`bool`, *opcional*, padrão `False`) : Se deve criar um PR com os arquivos enviados ou fazer o commit diretamente. max_shard_size (`int` ou `str`, *opcional*) : Tamanho máximo opcional dos shards do dataset a serem enviados para o hub. Se expresso como string, deve ser composto por dígitos seguidos de uma unidade (como `"5MB"`). Se não for fornecido, o número de shards padrão será o `.num_shards` deste dataset. num_shards (`int`, *opcional*) : Número de shards a serem gravados. Se `max_shard_size` for fornecido e `num_shards` não for, o número de shards é estimado a partir de `max_shard_size`. Pode ser maior que o `.num_shards` deste conjunto de dados: nesse caso, cada shard de entrada é distribuído em vários shards de saída, gravando seus exemplos neles de forma round-robin. embed_external_files (`bool`, padrão `True`) : Se deve incorporar os bytes dos arquivos nos shards. Em particular, isso fará o seguinte antes do push para os campos do tipo: - [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) e [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image): remover as informações de caminho local e incorporar o conteúdo do arquivo nos arquivos Parquet. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao preparar e enviar o dataset. Isso é útil se o dataset for composto por muitas amostras e transformações. Usa o contexto "spawn" para funcionar com hf_xet, o cliente rust para uploads rápidos para o HF. O multiprocessing é desabilitado por padrão. **Retorna:** huggingface_hub.CommitInfo Envia o dataset para o hub como um dataset Parquet. O dataset é enviado usando solicitações HTTP e não requer a instalação de git ou git-lfs. Os arquivos Parquet resultantes são autossuficientes por padrão. Se o seu conjunto de dados contiver dados de [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image), [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) ou [Video](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Video), os arquivos Parquet armazenarão os bytes das suas imagens ou arquivos de áudio. Você pode desativar isso definindo `embed_external_files` como `False`. Exemplo: ```python >>> dataset.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset.push_to_hub("/", max_shard_size="1GB") >>> dataset.push_to_hub("/", num_shards=1024) ``` Se o seu conjunto de dados tiver várias divisões (por exemplo, treino/validação/teste): ```python >>> train_dataset.push_to_hub("/", split="train") >>> val_dataset.push_to_hub("/", split="validation") >>> # later >>> dataset = load_dataset("/") >>> train_dataset = dataset["train"] >>> val_dataset = dataset["validation"] ``` Se você deseja adicionar uma nova configuração (ou subconjunto) a um conjunto de dados (por exemplo, se o conjunto de dados tiver várias tarefas/versões/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` #### load_state_dict[[datasets.IterableDataset.load_state_dict]] ```python load_state_dict(state_dict: dict) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2800) Carregue o state_dict do conjunto de dados. A iteração será retomada a partir do próximo exemplo do momento em que o estado foi salvo. Retomar retorna exatamente de onde o checkpoint foi salvo, exceto em dois casos: 1. exemplos dos buffers de embaralhamento são perdidos ao retomar e os buffers são reabastecidos com novos dados 2. combinações de `.with_format(arrow)` e `.map()` em lote podem pular um lote. Exemplo: ```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) ``` que retorna: ``` {'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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2747) **Retorna:** `dict` Obtenha o state_dict atual do dataset. Ele corresponde ao estado no exemplo mais recente que ele gerou. Retomar retorna exatamente de onde o checkpoint foi salvo, exceto em dois casos: 1. exemplos dos buffers de embaralhamento são perdidos ao retomar e os buffers são reabastecidos com novos dados 2. combinações de `.with_format(arrow)` e `.map()` em lote podem pular um lote. Exemplo: ```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) ``` que retorna: ``` {'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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L172) Objeto [DatasetInfo](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.DatasetInfo) contendo todos os metadados do conjunto de dados. #### split[[datasets.IterableDataset.split]] ```python split() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L177) objeto [NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit) correspondente a uma divisão nomeada do conjunto de dados. #### builder_name[[datasets.IterableDataset.builder_name]] ```python builder_name() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L182) #### citação[[datasets.IterableDataset.citation]] ```python citation() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L186) #### config_name[[datasets.IterableDataset.config_name]] ```python config_name() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L190) #### dataset_size[[datasets.IterableDataset.dataset_size]] ```python dataset_size() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L194) #### descrição[[datasets.IterableDataset.description]] ```python description() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L198) #### download_checksums[[datasets.IterableDataset.download_checksums]] ```python download_checksums() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L202) #### download_size[[datasets.IterableDataset.download_size]] ```python download_size() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L206) #### recursos[[datasets.IterableDataset.features]] ```python features() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L210) #### página inicial[[datasets.IterableDataset.homepage]] ```python homepage() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L214) #### licença[[datasets.IterableDataset.license]] ```python license() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L218) #### size_in_bytes[[datasets.IterableDataset.size_in_bytes]] ```python size_in_bytes() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L222) #### supervised_keys[[datasets.IterableDataset.supervised_keys]] ```python supervised_keys() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L226) #### versão[[datasets.IterableDataset.version]] ```python version() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/arrow_dataset.py#L230) #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3392) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) CSV. split ([NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `pandas.read_csv`. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Crie um IterableDataset a partir de arquivo(s) CSV. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3435) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) JSON ou JSON Lines. split ([NamedSplit](/docs/datasets/v5.2.0/pt/package_reference/builder_classes#datasets.NamedSplit), *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features ([Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features), *opcional*) : Recursos do conjunto de dados. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. field (`str`, *opcional*) : Nome do campo do arquivo JSON onde o conjunto de dados está contido. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `JsonConfig`. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Crie um IterableDataset a partir de arquivo(s) JSON ou JSON Lines. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3482) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) Parquet. split (`NamedSplit`, *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features (`Features`, *opcional*) : Recursos do conjunto de dados. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. columns (`List[str]`, *opcional*) : Se não for `None`, apenas essas colunas serão lidas do arquivo. O nome de uma coluna pode ser um prefixo de um campo aninhado, por exemplo, 'a' selecionará 'a.b', 'a.c' e 'a.d.e'. filters (`Union[pyarrow.dataset.Expression, list[tuple], list[list[tuple]]]`, *opcional*) : Retorna apenas as linhas que correspondem ao filtro. Se possível, o predicado será empurrado para baixo para explorar as informações de particionamento ou os metadados internos encontrados na fonte de dados, por exemplo, estatísticas do Parquet. Caso contrário, filtra os RecordBatches carregados antes de retorná-los. fragment_scan_options (`pyarrow.dataset.ParquetFragmentScanOptions`, *opcional*) : Opções específicas de varredura para fragmentos Parquet. Isso é especialmente útil para configurar bufferização e cache. on_bad_files (`Literal["error", "warn", "skip"]`, *opcional*, padrão "error") : Especifica o que fazer ao encontrar um arquivo inválido (um arquivo que não pode ser lido). Os valores permitidos são: * 'error', lança uma Exception quando um arquivo inválido é encontrado. * 'warn', lança um aviso quando um arquivo inválido é encontrado e ignora esse arquivo. * 'skip', ignora arquivos inválidos sem lançar exceção ou aviso quando são encontrados. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `ParquetConfig`. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Crie um IterableDataset a partir de arquivo(s) Parquet. Exemplo: ```py >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet') ``` Carregue um subconjunto de colunas: ```python >>> ds = IterableDataset.from_parquet('path/to/dataset.parquet', columns=["col_0", "col_1"]) ``` Filtre dados de forma eficiente, possivelmente pulando arquivos inteiros ou grupos de linhas: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L3567) **Parâmetros:** path_or_paths (`path-like` ou lista de `path-like`) : Caminho(s) do(s) arquivo(s) de texto. split (`NamedSplit`, *opcional*) : Nome da divisão a ser atribuído ao conjunto de dados. features (`Features`, *opcional*) : Recursos do conjunto de dados. keep_in_memory (`bool`, padrão `False`) : Se deve copiar os dados na memória. keep_linebreaks : (`bool`, padrão é False): Se deve manter quebras de linha. sample_by (`Literal["line", "paragraph", "document"]`, padrão "line") : Se os dados devem ser carregados por linha, parágrafo ou documento. Por padrão, uma linha no dataset = uma linha. - ****kwargs** (argumentos de palavra-chave adicionais) : Argumentos de palavra-chave a serem passados para `TextConfig`. **Retorna:** [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset) Crie um IterableDataset a partir de arquivo(s) de texto. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/iterable_dataset.py#L2657) Um iterável para uma coluna específica de um [IterableDataset](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset). Exemplo: Itere sobre os textos da coluna "text" de um dataset: ```python for text in dataset["text"]: ... ``` Ele também funciona com colunas aninhadas: ```python for source in dataset["metadata"]["source"]: ... ``` ## IterableDatasetDict[[datasets.IterableDatasetDict]] Dicionário com os nomes das divisões como chaves (por exemplo, 'train', 'test') e objetos `IterableDataset` como valores. #### datasets.IterableDatasetDict[[datasets.IterableDatasetDict]] [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1810) #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1911) **Parâmetros:** function (`Callable`, *opcional*, padrão `None`) : Função aplicada em tempo real nos exemplos ao iterar pelo dataset. Ela deve ter uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> Dict[str, Any]` se `batched=False` e `with_indices=False` - `function(example: Dict[str, Any], idx: int) -> Dict[str, Any]` se `batched=False` e `with_indices=True` - `function(batch: Dict[str, list]) -> Dict[str, list]` se `batched=True` e `with_indices=False` - `function(batch: Dict[str, list], indices: list[int]) -> Dict[str, list]` se `batched=True` e `with_indices=True` Para uso avançado, a função também pode retornar um `pyarrow.Table`. Se a função for assíncrona, o `map` executará sua função em paralelo. Além disso, se sua função não retornar nada (`None`), o `map` executará sua função e retornará o dataset inalterado. Se nenhuma função for fornecida, usa-se a função identidade por padrão: `lambda x: x`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, neste caso, a assinatura de `function` deve ser `def function(example, idx[, rank]): ...`. input_columns (`[Union[str, list[str]]]`, *opcional*, padrão `None`) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um dicionário mapeando para todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para a `function`. batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched=True`. drop_last_batch (`bool`, padrão `False`) : Se um último lote menor que o `batch_size` deve ser descartado em vez de ser processado pela função. remove_columns (`[list[str]]`, *opcional*, padrão `None`) : Remove uma seleção de colunas durante o mapeamento. As colunas serão removidas antes de atualizar os exemplos com a saída de `function`, ou seja, se `function` estiver adicionando colunas com nomes em `remove_columns`, essas colunas serão mantidas. fn_kwargs (`Dict`, *opcional*, padrão `None`) : Argumentos de palavra-chave a serem passados para `function` Aplica uma função a todos os exemplos no dataset iterável (individualmente ou em lotes) e os atualiza. Se a sua função retornar uma coluna que já existe, ela a sobrescreve. A função é aplicada em tempo real nos exemplos ao iterar sobre o dataset. A transformação é aplicada a todos os datasets do dicionário de datasets. Você pode especificar se a função deve ser processada em lote ou não com o parâmetro `batched`: - Se `False`, a função recebe 1 exemplo e deve retornar 1 exemplo. Um exemplo é um dicionário, por exemplo, `{"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 !"]}`. - Se `True` e `batch_size` é `n` > 1, a função recebe um lote de `n` exemplos como entrada e pode retornar um lote com `n` exemplos, ou com um número arbitrário de exemplos. Observe que o último lote pode ter menos de `n` exemplos. Um lote é um dicionário, por exemplo, um lote de `n` exemplos é `{"text": ["Hello there !"] * n}`. Se a função for assíncrona, `map` executará sua função em paralelo, com até mil chamadas simultâneas. É recomendável usar um `asyncio.Semaphore` na sua função se você quiser definir um número máximo de operações que podem ser executadas ao mesmo tempo. Exemplo: ```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 .'} ``` #### filtro[[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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2011) **Parâmetros:** function (`Callable`) : Chamável com uma das seguintes assinaturas: - `function(example: Dict[str, Any]) -> bool` se `with_indices=False, batched=False` - `function(example: Dict[str, Any], indices: int) -> bool` se `with_indices=True, batched=False` - `function(example: Dict[str, list]) -> list[bool]` se `with_indices=False, batched=True` - `function(example: Dict[str, list], indices: list[int]) -> list[bool]` se `with_indices=True, batched=True` Se nenhuma função for fornecida, o padrão é uma função que sempre retorna True: `lambda x: True`. with_indices (`bool`, padrão `False`) : Fornece índices de exemplo para `function`. Observe que, nesse caso, a assinatura de `function` deve ser `def function(example, idx): ...`. input_columns (`str` ou `list[str]`, *opcional*) : As colunas a serem passadas para `function` como argumentos posicionais. Se `None`, um dicionário mapeando para todas as colunas formatadas é passado como um único argumento. batched (`bool`, padrão `False`) : Fornece um lote de exemplos para `function` batch_size (`int`, *opcional*, padrão `1000`) : Número de exemplos por lote fornecidos a `function` se `batched=True`. fn_kwargs (`Dict`, *opcional*, padrão `None`) : Argumentos de palavra-chave a serem passados para `function` Aplica uma função de filtro a todos os elementos para que o conjunto de dados inclua apenas exemplos de acordo com a função de filtro. O filtramento é feito em tempo real ao iterar sobre o conjunto de dados. O filtramento é aplicado a todos os conjuntos de dados do dicionário de conjuntos de dados. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2074) **Parâmetros:** seed (`int`, *opcional*, padrão `None`) : Semente aleatória que será usada para embaralhar o conjunto de dados. É usada para amostrar do buffer de embaralhamento e também para embaralhar os fragmentos de dados. generator (`numpy.random.Generator`, *opcional*) : Gerador aleatório do Numpy a ser usado para calcular a permutação das linhas do conjunto de dados. Se `generator=None` (padrão), usa `np.random.default_rng` (o BitGenerator padrão (PCG64) do NumPy). buffer_size (`int`, padrão `1000`) : Tamanho do buffer. max_buffer_input_shards (`int`, padrão `10`) : Número máximo de shards a serem usados para alimentar o buffer de uma vez. Embaralha aleatoriamente os elementos deste conjunto de dados. O embaralhamento é aplicado a todos os conjuntos de dados do dicionário de conjuntos de dados. Este conjunto de dados preenche um buffer com buffer_size elementos e, em seguida, amostra aleatoriamente elementos deste buffer, substituindo os elementos selecionados por novos elementos. Para uma embaralhamento perfeito, é necessário um tamanho de buffer maior ou igual ao tamanho total do conjunto de dados. Por exemplo, se o seu conjunto de dados contém 10.000 elementos, mas `buffer_size` está definido como 1000, então `shuffle` inicialmente selecionará um elemento aleatório apenas dos primeiros 1000 elementos no buffer. Assim que um elemento é selecionado, seu espaço no buffer é substituído pelo próximo (ou seja, o 1.001º) elemento, mantendo o buffer de 1000 elementos. Se o conjunto de dados é composto por vários shards, ele também realiza `shuffle` na ordem dos shards. No entanto, se a ordem foi fixada usando [skip()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.skip) ou [take()](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDataset.take), a ordem dos shards permanece inalterada. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L1865) **Parâmetros:** type (`str`, *opcional*) : Tipo de saída selecionado em `[None, 'numpy', 'torch', 'tensorflow', 'jax', 'arrow', 'pandas', 'polars']`. `None` significa que retorna objetos python (padrão). Retorne um conjunto de dados com o formato especificado. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2290) **Parâmetros:** features (`Features`) : Novos recursos para os quais o dataset será convertido. Os nomes dos campos nos recursos devem corresponder aos nomes atuais das colunas. O tipo dos dados também deve ser convertível de um tipo para o outro. Para conversões não triviais, por exemplo, `string` <-> `ClassLabel`, você deve usar `map` para atualizar o Dataset. **Retorna:** [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) Uma cópia do conjunto de dados com recursos convertidos. Casteie o conjunto de dados para um novo conjunto de recursos. O cast de tipo é aplicado a todos os conjuntos de dados do dicionário de conjuntos de dados. Exemplo: ```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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2259) **Parâmetros:** column (`str`) : Nome da coluna. feature (`Feature`) : Recurso alvo. **Retorna:** [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) Converte a coluna em recurso para decodificação. A conversão de tipo é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. Exemplo: ```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]]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2207) **Parâmetros:** column_names (`Union[str, list[str]]`) : Nome da(s) coluna(s) a ser(em) removida(s). **Retorna:** [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) Uma cópia do objeto de dataset sem as colunas a serem removidas. Remove uma ou várias colunas do dataset e os recursos associados a elas. A remoção é feita em tempo real nos exemplos ao iterar sobre o dataset. A remoção é aplicada a todos os datasets do dicionário de datasets. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2143) **Parâmetros:** original_column_name (`str`) : Nome da coluna a ser renomeada. new_column_name (`str`) : Novo nome para a coluna. **Retorna:** [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) Uma cópia do conjunto de dados com uma coluna renomeada. Renomeia uma coluna no dataset e move os recursos associados à coluna original para o novo nome da coluna. A renomeação é aplicada a todos os datasets do dicionário de datasets. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2179) **Parâmetros:** column_mapping (`Dict[str, str]`) : Um mapeamento de colunas para renomear para seus novos nomes. **Retorna:** [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) Uma cópia do conjunto de dados com colunas renomeadas Renomeie várias colunas no conjunto de dados e mova os recursos associados às colunas originais para os novos nomes de coluna. O renomeamento é aplicado a todos os conjuntos de dados do dicionário de conjuntos de dados. Exemplo: ```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]]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2233) **Parâmetros:** column_names (`Union[str, list[str]]`) : Nome da(s) coluna(s) a ser(em) mantida(s). **Retorna:** [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) Uma cópia do objeto de dataset com apenas as colunas selecionadas. Selecione uma ou várias colunas no conjunto de dados e os recursos associados a elas. A seleção é feita em tempo real nos exemplos ao iterar sobre o conjunto de dados. A seleção é aplicada a todos os conjuntos de dados do dicionário de conjuntos de dados. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/dataset_dict.py#L2327) **Parâmetros:** repo_id (`str`) : O ID do repositório para o qual será feito o push, no seguinte formato: `/` ou `/`. Também aceita ``, que usará o namespace do usuário conectado por padrão. Também pode ser um local dentro de um bucket, por exemplo, `buckets///...` config_name (`str`) : Nome da configuração de um conjunto de dados. O padrão é "default". set_default (`bool`, *opcional*) : Se deve definir esta configuração como a padrão. Caso contrário, a configuração padrão é a nomeada "default". data_dir (`str`, *opcional*) : Nome do diretório que conterá os arquivos de dados enviados. O padrão é `config_name` se for diferente de "default", caso contrário, "data". commit_message (`str`, *opcional*) : Mensagem a ser commitada durante o push. O padrão será `"Upload dataset"`. commit_description (`str`, *opcional*) : Descrição do commit que será criado. Além disso, descrição da PR, caso uma PR seja criada (`create_pr` é True). private (`bool`, *opcional*) : Se deve tornar o repositório privado. Se `None` (padrão), o repositório será público, a menos que o padrão da organização seja privado. Este valor é ignorado se o repositório já existir. token (`str`, *opcional*) : Um token de autenticação opcional para o Hugging Face Hub. Se nenhum token for passado, será usado o token salvo localmente ao fazer login com `hf auth login`. Será gerado um erro se nenhum token for passado e o usuário não estiver conectado. revision (`str`, *opcional*) : Branch para o qual os arquivos enviados serão enviados. O padrão é a branch `"main"`. create_pr (`bool`, *opcional*, padrão `False`) : Se deve criar um PR com os arquivos enviados ou fazer o commit diretamente. max_shard_size (`int` ou `str`, *opcional*) : Tamanho máximo opcional dos shards do dataset a serem enviados para o hub. Se expresso como string, precisa ser dígitos seguidos por uma unidade (como `"500MB"` ou `"1GB"`). Se não for fornecido, cada split mantém a contagem de shards nativa do dataset. num_shards (`Dict[str, int]`, *opcional*) : Número de shards a serem gravados. Use um dicionário para definir um `num_shards` diferente para cada split. Se `max_shard_size` for fornecido e o `num_shards` de um split não for, então o número de shards para esse split é estimado a partir de `max_shard_size`. embed_external_files (`bool`, padrão `True`) : Se deve incorporar os bytes dos arquivos nos shards. Em particular, isso fará o seguinte antes do push para os campos do tipo: - [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) e [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image) remove as informações de caminho local e incorpora o conteúdo do arquivo nos arquivos Parquet. num_proc (`int`, *opcional*, padrão `None`) : Número de processos ao preparar e enviar o dataset. Isso é útil se o dataset for composto por muitas amostras ou arquivos de mídia para incorporar. Usa o contexto "spawn" para funcionar com hf_xet, o cliente rust para uploads rápidos para o HF. O multiprocessing é desabilitado por padrão. **Retorna:** huggingface_hub.CommitInfo Envia o [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) para o hub como um dataset Parquet. O [IterableDatasetDict](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.IterableDatasetDict) é enviado usando requisições HTTP e não requer a instalação de git ou git-lfs. Cada divisão do conjunto de dados será enviada de forma independente. O conjunto de dados enviado manterá os nomes originais das divisões. Os arquivos Parquet resultantes são autossuficientes por padrão: se o seu conjunto de dados contiver dados de [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image) ou [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio), os arquivos Parquet armazenarão os bytes das suas imagens ou arquivos de áudio. Você pode desativar isso definindo `embed_external_files` como False. Exemplo: ```python >>> dataset_dict.push_to_hub("/") >>> dataset_dict.push_to_hub("/", private=True) >>> dataset_dict.push_to_hub("/", max_shard_size="1GB") >>> dataset_dict.push_to_hub("/", num_shards={"train": 1024, "test": 8}) ``` Se você deseja adicionar uma nova configuração (ou subconjunto) a um conjunto de dados (por exemplo, se o conjunto de dados tiver várias tarefas/versões/idiomas): ```python >>> english_dataset.push_to_hub("/", "en") >>> french_dataset.push_to_hub("/", "fr") >>> # later >>> english_dataset = load_dataset("/", "en") >>> french_dataset = load_dataset("/", "fr") ``` ## Recursos[[datasets.Features]] #### datasets.Features[[datasets.Features]] ```python datasets.Features(*args, **kwargs) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1931) Um dicionário especial que define a estrutura interna de um conjunto de dados. Instanciada com um dicionário do tipo `dict[str, FieldType]`, onde as chaves são os nomes das colunas desejados e os valores são o tipo de cada coluna. `FieldType` pode ser um dos seguintes: - O recurso [Value](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Value) especifica um valor de um único tipo de dados, por exemplo, `int64` ou `string`. - A feature [ClassLabel](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.ClassLabel) especifica um conjunto predefinido de classes que podem ter rótulos associados e que serão armazenados como inteiros no dataset. - Um `dict` do Python especifica um recurso composto que contém um mapeamento de subcampos para subrecursos. É possível ter campos aninhados de campos aninhados de maneira arbitrária. - [List](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.List) ou [LargeList](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.LargeList) especifica um recurso composto que contém uma sequência de sub-recursos, todos do mesmo tipo de recurso. - [Array2D](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Array2D), [Array3D](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Array3D), [Array4D](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Array4D) ou [Array5D](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Array5D) para recursos de arrays multidimensionais. - [Audio](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Audio) recurso para armazenar o caminho absoluto para um arquivo de áudio ou um dicionário com o caminho relativo para um arquivo de áudio (chave "path") e seu conteúdo em bytes (chave "bytes"). Este recurso carrega o áudio de forma preguiçosa com um decodificador. - [Image](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Image) para armazenar o caminho absoluto para um arquivo de imagem, um objeto `np.ndarray`, um objeto `PIL.Image.Image` ou um dicionário com o caminho relativo para um arquivo de imagem (chave "path") e seu conteúdo em bytes (chave "bytes"). Este recurso extrai os dados da imagem. - [Video](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Video) recurso para armazenar o caminho absoluto para um arquivo de vídeo, um objeto `torchcodec.decoders.VideoDecoder` ou um dicionário com o caminho relativo para um arquivo de vídeo (chave "path") e seu conteúdo em bytes (chave "bytes"). Este recurso carrega o vídeo de forma preguiçosa com um decodificador. - [Pdf](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Pdf) recurso para armazenar o caminho absoluto para um arquivo PDF, um objeto `pdfplumber.pdf.PDF` ou um dicionário com o caminho relativo para um arquivo PDF (chave "path") e seu conteúdo em bytes (chave "bytes"). Este recurso carrega o PDF de forma preguiçosa com um leitor de PDF. - [Nifti](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Nifti) recurso para armazenar o caminho absoluto para um arquivo de neuroimagem NIfTI, um objeto `nibabel.Nifti1Image` ou um dicionário com o caminho relativo para um arquivo NIfTI (chave "path") e seu conteúdo em bytes (chave "bytes"). Este recurso carrega o arquivo NIfTI de forma preguiçosa com nibabel. - [Translation](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Translation) ou [TranslationVariableLanguages](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.TranslationVariableLanguages), recurso específico de Tradução Automática. - [Json](/docs/datasets/v5.2.0/pt/package_reference/loading_methods#datasets.Json) recurso para armazenar dados não estruturados, por exemplo, contendo tipos mistos/arbitrários. Por baixo dos panos #### copiar[[datasets.Features.copy]] ```python copy() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2364) **Retorna:** [Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features) Faça uma cópia profunda de [Features](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features). Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2337) **Parâmetros:** batch (`dict[str, list[Any]]`) : Dados do lote do dataset. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de áudio ou imagem de repositórios privados no Hub, você pode passar um dicionário repo_id (str) -> token (bool or str) **Retorna:** `dict[str, list[Any]]` Decodificar lote com decodificação de recursos personalizada. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2312) **Parâmetros:** column (`list[Any]`) : dados da coluna do Dataset. column_name (`str`) : Nome da coluna do dataset. **Retorna:** `list[Any]` Decodifique a coluna com decodificação de recurso personalizada. #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2289) **Parâmetros:** example (`dict[str, Any]`) : Dados da linha do dataset. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de áudio ou imagem de repositórios privados no Hub, você pode passar um dicionário `repo_id (str) -> token (bool or str)`. **Retorna:** `dict[str, Any]` Exemplo de decodificação com decodificação de recursos personalizada. #### encode_batch[[datasets.Features.encode_batch]] ```python encode_batch(batch) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2270) **Parâmetros:** batch (`dict[str, list[Any]]`) : Dados em um lote de Dataset. **Retorna:** `dict[str, list[Any]]` Codifica o lote em um formato para Arrow. #### encode_column[[datasets.Features.encode_column]] ```python encode_column(column, column_name: str) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2254) **Parâmetros:** column (`list[Any]`) : Dados em uma coluna de Dataset. column_name (`str`) : Nome da coluna do dataset. **Retorna:** `list[Any]` Codifica a coluna em um formato para Arrow. #### encode_example[[datasets.Features.encode_example]] ```python encode_example(example) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2240) **Parâmetros:** example (`dict[str, Any]`) : Dados em uma linha de Dataset. **Retorna:** `dict[str, Any]` Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.Features.flatten]] ```python flatten(max_depth = 16) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2437) **Retorna:** [Features](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features) Os recursos achatados. Achate os recursos. Cada coluna de dicionário é removida e substituída por todos os subcampos que ela contém. Os novos campos são nomeados concatenando o nome da coluna original e o nome do subcampo da seguinte forma: `.`. Se uma coluna contém dicionários aninhados, os nomes de todos os subcampos de níveis inferiores também são concatenados para formar novas colunas: `..`, etc. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2023) **Parâmetros:** pa_schema (`pyarrow.Schema`) : Esquema Arrow. **Retorna:** [Recursos](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features) Constrói [Features](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Features) a partir do Schema Arrow. Também verifica os metadados do schema para os recursos do Hugging Face Datasets. Campos não anuláveis não são suportados e são definidos como anuláveis. Além disso, pa.dictionary não é suportado e ele usa seu tipo subjacente no lugar. Portanto, os datasets convertem objetos DictionaryArray para seus valores reais. #### from_dict[[datasets.Features.from_dict]] ```python from_dict(dic) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2057) **Parâmetros:** dic (*dict[str, Any]*) : Dicionário Python. **Retorna:** `*Features*` Construir [*Features*] a partir de um dict. Regenera o objeto de recurso aninhado a partir de um dicionário desserializado. Usamos a chave *_type* para inferir o nome da dataclass do recurso *FieldType*. Isso permite uma sintaxe de construtor conveniente para definir recursos a partir de dicionários JSON desserializados. Esta função é usada, em particular, ao desserializar um [*DatasetInfo*] que foi exportado para um objeto JSON. Isso atua como um análogo de [*Features.from_arrow_schema*] e lida com a instanciação recursiva campo a campo, mas não requer nenhum mapeamento para/pyarrow, exceto pelo fato de aproveitar o mapeamento dos tipos de dados primitivos do pyarrow que o [*Value*] executa automaticamente. Exemplo: ```python >>> Features.from_dict(&lcub;'_type': &lcub;'dtype': 'string', 'id': None, '_type': 'Value'}}) &lcub;'_type': Value('string')} ``` #### reorder_fields_as[[datasets.Features.reorder_fields_as]] ```python reorder_fields_as(other: Features) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L2384) **Parâmetros:** other ([*Recursos*]) : Os outros [*Recursos*] para alinhar. **Retorna:** [*Recursos*] Reordene os campos de Features para corresponder à ordem dos campos de outros [*Features*]. A ordem dos campos é importante, pois afeta os dados subjacentes do arrow. Reordenar os campos permite que o tipo de dados subjacente do arrow corresponda. Exemplo: ```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(&lcub;"root": &lcub;"a": Value("string"), "b": Value("string")}}) >>> f2 = Features(&lcub;"root": &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) &lcub;'root': List(&lcub;'b': Value('string'), 'a': Value('string')})} >>> assert f1.reorder_fields_as(f2).type == f2.type ``` ### Escalar[[datasets.Value]] #### datasets.Value[[datasets.Value]] ```python datasets.Value(dtype: str, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L511) **Parâmetros:** dtype (`str`) : Nome do tipo de dados. Valor de recurso escalar de um determinado tipo de dados. Os possíveis dtypes de `Value` são os seguintes: - `null` - `bool` - `int8` - `int16` - `int32` - `int64` - `uint8` - `uint16` - `uint32` - `uint64` - `float16` - `float32` (alias float) - `float64` (alias double) - `time32[(s|ms)]` - `time64[(us|ns)]` - `timestamp[(s|ms|us|ns)]` - `timestamp[(s|ms|us|ns), tz=(tzstring)]` - `date32` - `date64` - `duration[(s|ms|us|ns)]` - `decimal128(precision, scale)` - `decimal256(precision, scale)` - `binary` - `large_binary` - `binary_view` - `string` - `large_string` - `string_view` Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1052) **Parâmetros:** num_classes (`int`, *opcional*) : Número de classes. Todos os rótulos devem ser < `num_classes`. names (`list` de `str`, *opcional*) : Nomes de string para as classes inteiras. A ordem em que os nomes são fornecidos é mantida. names_file (`str`, *opcional*) : Caminho para um arquivo com os nomes das classes inteiras, um por linha. Tipo de recurso para rótulos de classe inteira. Existem 3 maneiras de definir um `ClassLabel`, que correspondem aos 3 argumentos: * `num_classes`: Cria rótulos de 0 a (num_classes-1). * `names`: Lista de strings de rótulos. * `names_file`: Arquivo contendo a lista de rótulos. Por baixo dos panos, os rótulos são armazenados como inteiros. Você pode usar -1 para representar rótulos desconhecidos/ausentes. Exemplo: ```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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1217) **Parâmetros:** storage (`Union[pa.StringArray, pa.IntegerArray]`) : array do PyArrow para converter. **Retorna:** `pa.Int64Array` Array no tipo de armazenamento arrow `ClassLabel`. Converte um array Arrow para o tipo de armazenamento arrow `ClassLabel`. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento pyarrow `ClassLabel` são: - `pa.string()` - `pa.int()` #### int2str[[datasets.ClassLabel.int2str]] ```python int2str(values: typing.Union[int, collections.abc.Iterable]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1171) Conversão `integer` => nome da classe `string`. Em relação a rótulos desconhecidos/ausentes: passar inteiros negativos levanta `ValueError`. Exemplo: ```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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1126) Nome da classe de conversão `string` => `integer`. Exemplo: ```py >>> from datasets import load_dataset >>> ds = load_dataset("cornell-movie-review-data/rotten_tomatoes", split="train") >>> ds.features["label"].str2int('neg') 0 ``` ### Composto[[datasets.LargeList]] #### datasets.LargeList[[datasets.LargeList]] ```python datasets.LargeList(feature: typing.Any, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1414) **Parâmetros:** feature (`FeatureType`) : Tipo de dados da característica filha de cada item dentro da lista grande. Tipo de recurso para dados de listas grandes compostos pelo tipo de dados de recurso filho. Ele é baseado em `pyarrow.LargeListType`, que é como `pyarrow.ListType`, mas com offsets de 64 bits em vez de 32 bits. #### datasets.List[[datasets.List]] ```python datasets.List(feature: typing.Any, length: int = -1, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1386) **Parâmetros:** feature (`FeatureType`) : Tipo de dados da característica filha de cada item dentro da lista grande. length (opcional `int`, padrão -1) : Comprimento da lista, caso seja fixo. O padrão é -1, o que significa um comprimento arbitrário. Tipo de recurso para dados de listas grandes compostos pelo tipo de dados de recurso filho. É baseado em `pyarrow.ListType`, que usa offsets de 32 bits ou um comprimento fixo. #### datasets.Sequence[[datasets.Sequence]] ```python datasets.Sequence(feature = None, length = -1, **kwargs) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1352) **Parâmetros:** feature (`FeatureType`) : Tipo de dados da característica filha de cada item dentro da lista grande. length (opcional `int`, padrão -1) : Comprimento da lista, caso seja fixo. O padrão é -1, o que significa um comprimento arbitrário. **Retorna:** [Lista](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.List) da feature especificada, exceto `dict` de sub-features, que são convertidas em `dict` de listas de sub-features para compatibilidade com o TFDS. Uma `Sequence` é uma utilidade que converte automaticamente um recurso de dicionário interno em um dicionário de listas. Esse comportamento é implementado para ter uma camada de compatibilidade com a biblioteca TensorFlow Datasets, mas pode não ser desejado em alguns casos. Se você não quiser esse comportamento, pode usar uma [List](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.List) ou uma [LargeList](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.LargeList) em vez da [Sequence](/docs/datasets/v5.2.0/pt/package_reference/main_classes#datasets.Sequence). ### Tradução[[datasets.Translation]] #### datasets.Translation[[datasets.Translation]] ```python datasets.Translation(languages: list, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L12) **Parâmetros:** languages (`dict`) : Um dicionário para cada exemplo, mapeando códigos de idioma em strings para traduções em strings. `Feature` para traduções com idiomas fixos por exemplo. Aqui, para compatibilidade com tfds. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L44) Aplique a funcionalidade Flatten the Translation em um dicionário. #### datasets.TranslationVariableLanguages[[datasets.TranslationVariableLanguages]] ```python datasets.TranslationVariableLanguages(languages: typing.Optional[list] = None, num_languages: typing.Optional[int] = None, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L52) **Parâmetros:** languages (`dict`) : Um dicionário para cada exemplo, mapeando códigos de idioma em string para uma ou mais traduções em string. Os idiomas presentes podem variar de um exemplo para outro. **Retorna:** - `language` ou `translation` (`tf.Tensor` unidimensional de `tf.string` com comprimento variável) Códigos de idioma ordenados em ordem ascendente ou traduções em texto simples, ordenados para alinhar com os códigos de idioma. `Feature` para traduções com idiomas variáveis por exemplo. Aqui, para compatibilidade com tfds. Exemplo: ```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() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/translation.py#L122) Aplique a função Flatten na feature TranslationVariableLanguages para convertê-la em um dicionário. ### Arrays[[datasets.Array2D]] #### datasets.Array2D[[datasets.Array2D]] ```python datasets.Array2D(shape: tuple, dtype: str, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L608) **Parâmetros:** shape (`tuple`) : Tamanho de cada dimensão. dtype (`str`) : Nome do tipo de dados. Crie um array bidimensional. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L633) **Parâmetros:** shape (`tuple`) : Tamanho de cada dimensão. dtype (`str`) : Nome do tipo de dados. Crie um array tridimensional. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L658) **Parâmetros:** shape (`tuple`) : Tamanho de cada dimensão. dtype (`str`) : Nome do tipo de dados. Crie um array de quatro dimensões. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L683) **Parâmetros:** shape (`tuple`) : Tamanho de cada dimensão. dtype (`str`) : Nome do tipo de dados. Crie um array de cinco dimensões. Exemplo: ```py >>> from datasets import Features >>> features = Features({'x': Array5D(shape=(1, 2, 2, 3, 3), dtype='int32')}) ``` ### Áudio[[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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L24) **Parâmetros:** sampling_rate (`int`, *opcional*) : Taxa de amostragem alvo. Se `None`, a taxa de amostragem nativa é utilizada. num_channels (`int`, *opcional*) : O número desejado de canais das amostras. Por padrão, é utilizado o número de canais da fonte. A decodificação de áudio retornará amostras com a forma (num_channels, num_samples) Atualmente, são suportados `None` (número de canais da fonte, padrão), `1` (mono) ou `2` (estéreo) canais. O argumento `num_channels` é passado para `torchcodec.decoders.AudioDecoder`. decode (`bool`, padrão `True`) : Se deve decodificar os dados de áudio. Se `False`, retorna o dicionário subjacente no formato `{"path": audio_path, "bytes": audio_bytes}`. stream_index (`int`, *opcional*) : O índice de streaming a ser usado do arquivo. Se `None`, o padrão é o índice "melhor". Audio `Feature` para extrair dados de áudio de um arquivo de áudio. Input: O recurso de áudio aceita como entrada: - Uma `str`: caminho absoluto para o arquivo de áudio (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo de áudio (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo de áudio em relação ao arquivo de arquivo. - `bytes`: Bytes content of the audio file. Isso é útil para arquivos parquet ou webdataset que incorporam arquivos de áudio. - Um `dict` com as chaves: - `array`: Matriz contendo a amostra de áudio - `sampling_rate`: Inteiro correspondente à taxa de amostragem da amostra de áudio. - Um objeto de decodificador de áudio do torchcodec: `torchcodec.decoders.AudioDecoder`. Saída: Os recursos de áudio saem como objetos `torchcodec.decoders.AudioDecoder`, com chaves adicionais: - `array`: Matriz contendo a amostra de áudio - `sampling_rate`: Inteiro correspondente à taxa de amostragem da amostra de áudio. Exemplo: ```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"] >>> 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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L237) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento de áudio arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})` Converte um array Arrow para o tipo de armazenamento de áudio Arrow. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento de áudio pyarrow são: - `pa.string()` - deve conter os dados "path" - `pa.binary()` - deve conter os bytes de áudio - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L164) **Parâmetros:** value (`dict`) : Um dicionário com as chaves: - `path`: String com o caminho relativo do arquivo de áudio. - `bytes`: Bytes do arquivo de áudio. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de áudio de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`) **Retorna:** `torchcodec.decoders.AudioDecoder` Decodifique o arquivo de áudio de exemplo em dados de áudio. #### embed_storage[[datasets.Audio.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L283) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos locais no array remote_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos remotos no array. Por exemplo, arquivos com caminhos que começam com hf:// ou https:// **Retorna:** `pa.StructArray` Array no tipo de armazenamento de áudio arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incorpore arquivos de áudio no array Arrow. #### encode_example[[datasets.Audio.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('AudioDecoder')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L96) **Parâmetros:** value (`str`, `bytes`,`bytearray`,`dict`, `AudioDecoder`) : Dados passados como entrada para o recurso de áudio. **Retorna:** `dict` Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.Audio.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/audio.py#L226) Se estiver no estado decodificável, lance um erro; caso contrário, achate o recurso em um dicionário. ### Imagem[[datasets.Image]] #### datasets.Image[[datasets.Image]] ```python datasets.Image(mode: typing.Optional[str] = None, decode: bool = True, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L47) **Parâmetros:** mode (`str`, *opcional*) : O modo para converter a imagem. Se `None`, o modo nativo da imagem é usado. decode (`bool`, padrão `True`) : Se deve decodificar os dados da imagem. Se `False`, retorna o dicionário subjacente no formato `{"path": image_path, "bytes": image_bytes}`. Imagem `Feature` para ler dados de imagem de um arquivo de imagem. Input: O recurso de imagem aceita como entrada: - Uma `str`: caminho absoluto para o arquivo de imagem (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo de imagem (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo de imagem em relação ao arquivo de arquivo. - `bytes`: Bytes do arquivo de imagem. Isso é útil para arquivos parquet ou webdataset que incorporam arquivos de imagem. - Um `np.ndarray`: um array NumPy representando uma imagem. - Um objeto de imagem PIL: `PIL.Image.Image`. Saída: Os recursos de imagem saem como objetos `PIL.Image.Image`. Exemplos: ```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"] >>> 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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L216) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento Image arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Converte um array Arrow para o tipo de armazenamento de imagem Arrow. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento de imagem pyarrow são: - `pa.string()` - deve conter os dados "path" - `pa.large_string()` - deve conter os dados "path" (será convertido para string, se possível) - `pa.binary()` - deve conter os bytes da imagem - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa - `pa.list(*)` - deve conter os dados do array de imagens #### decode_example[[datasets.Image.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L139) **Parâmetros:** value (`str` ou `dict`) : Uma string com o caminho absoluto do arquivo de imagem, um dicionário com as chaves: - `path`: String com o caminho absoluto ou relativo do arquivo de imagem. - `bytes`: Os bytes do arquivo de imagem. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de imagem de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`). **Retorna:** `PIL.Image.Image` Decodifique o arquivo de imagem de exemplo em dados de imagem. #### embed_storage[[datasets.Image.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L278) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos locais no array remote_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos remotos no array. Por exemplo, arquivos com caminhos que começam com hf:// ou https:// **Retorna:** `pa.StructArray` Array no tipo de armazenamento Image arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incorpore arquivos de imagem no array Arrow. #### encode_example[[datasets.Image.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, numpy.ndarray, ForwardRef('PIL.Image.Image')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L98) **Parâmetros:** value (`str`, `np.ndarray`, `PIL.Image.Image` ou `dict`) : Dados passados como entrada para o recurso de imagem. **Retorna:** `dict` com os campos "path" e "bytes" Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.Image.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/image.py#L203) Se estiver no estado decodificável, retorne o próprio recurso; caso contrário, achate o recurso em um dicionário. ### Vídeo[[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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L29) **Parâmetros:** decode (`bool`, padrão `True`) : Se deve decodificar os dados do vídeo. Se `False`, retorna o dicionário subjacente no formato `{"path": video_path, "bytes": video_bytes}`. stream_index (`int`, *opcional*) : O índice de streaming a ser usado do arquivo. Se `None`, o padrão é o índice "melhor". dimension_order (`str`, padrão `NCHW`) : A ordem das dimensões dos quadros decodificados. onde N é o tamanho do lote, C é o número de canais, H é a altura e W é a largura dos quadros. num_ffmpeg_threads (`int`, padrão `1`) : O número de threads a serem usadas para decodificar o vídeo. (Recomenda-se manter este valor em 1) device (`str` ou `torch.device`, padrão `cpu`) : O dispositivo a ser usado para decodificar o vídeo. seek_mode (`str`, padrão `exact`) : Determina se o acesso ao frame será “exact” ou “approximate”. Exact garante que a solicitação do frame i retornará sempre o frame i, mas isso requer uma varredura inicial do arquivo. Approximate é mais rápido, pois evita a varredura do arquivo, mas é menos preciso, pois usa os metadados do arquivo para calcular onde i provavelmente está. leia mais [aqui](https://docs.pytorch.org/torchcodec/stable/generated_examples/approximate_mode.html#sphx-glr-generated-examples-approximate-mode-py) Video `Feature` para ler dados de vídeo de um arquivo de vídeo. Input: O recurso de vídeo aceita como entrada: - Uma `str`: caminho absoluto para o arquivo de vídeo (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo de vídeo (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo de vídeo em um repositório de dataset. - `bytes`: Bytes do arquivo de vídeo. Isso é útil para arquivos parquet ou webdataset que incorporam arquivos de vídeo. - Um objeto de decodificador de vídeo do torchcodec: `torchcodec.decoders.VideoDecoder`. Saída: A saída de Vídeo apresenta os dados como objetos `torchcodec.decoders.VideoDecoder`. Exemplos: ```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"] >>> 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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L242) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento de vídeo arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Converte um array Arrow para o tipo de armazenamento de vídeo do Arrow. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento de vídeo do pyarrow são: - `pa.string()` - deve conter os dados "path" - `pa.binary()` - deve conter os bytes do vídeo - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa - `pa.list(*)` - deve conter os dados do array de vídeo #### 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L153) **Parâmetros:** value (`str` ou `dict`) : Uma string com o caminho absoluto do arquivo de vídeo, um dicionário com as chaves: - `path`: String com o caminho absoluto ou relativo do arquivo de vídeo. - `bytes`: Os bytes do arquivo de vídeo. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de vídeo de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`). **Retorna:** `torchcodec.decoders.VideoDecoder` Decodifique o arquivo de vídeo de exemplo em dados de vídeo. #### embed_storage[[datasets.Video.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L294) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos locais no array remote_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos remotos no array. Por exemplo, arquivos com caminhos que começam com hf:// ou https:// **Retorna:** `pa.StructArray` Array no tipo de armazenamento de vídeo arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incorpore arquivos de imagem no array Arrow. #### encode_example[[datasets.Video.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, datasets.features.video.Example, numpy.ndarray, ForwardRef('VideoDecoder')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L105) **Parâmetros:** value (`str`, `np.ndarray`, `bytes`, `bytearray`, `VideoDecoder` ou `dict`) : Dados passados como entrada para o recurso de Vídeo. **Retorna:** `dict` com os campos "path" e "bytes" Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.Video.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/video.py#L229) Se estiver no estado decodificável, retorne o próprio recurso; caso contrário, achate o recurso em um dicionário. ### Mesh[[datasets.Mesh]] #### datasets.Mesh[[datasets.Mesh]] ```python datasets.Mesh(decode: bool = True, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L23) **Parâmetros:** decode (`bool`, padrão `True`) : Se deve decodificar os dados da malha. Se `False`, retorna o dicionário subjacente no formato `{"path": mesh_path, "bytes": mesh_bytes}`. A decodificação da malha usa `trimesh` e suporta arquivos `.glb`, `.gltf`, `.ply` e `.stl`. Mesh `Feature` para ler dados de malha 3D de um arquivo. Input: O recurso Mesh aceita como entrada: - Uma `str`: caminho absoluto para o arquivo de malha (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo de malha (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo de malha em relação ao arquivo de arquivo. - `bytes`: Bytes do arquivo de malha. Isso é útil para arquivos parquet ou webdataset que incorporam arquivos de malha. - Um `trimesh.Trimesh` ou `trimesh.Scene`: objeto de malha 3D ou cena. Saída: O recurso Mesh gera dados como objetos `trimesh.Trimesh` ou `trimesh.Scene`. #### cast_storage[[datasets.Mesh.cast_storage]] ```python cast_storage(storage: typing.Union[pyarrow.lib.StringArray, pyarrow.lib.StructArray]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L162) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento Mesh arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Converte um array Arrow para o tipo de armazenamento arrow do Mesh. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento pyarrow do Mesh são: - `pa.string()` - deve conter os dados "path" - `pa.large_string()` - deve conter os dados "path" (será convertido para string, se possível) - `pa.binary()` - deve conter os bytes da malha - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa #### decode_example[[datasets.Mesh.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L91) **Parâmetros:** value (`dict`) : Um dicionário com as chaves: - `path`: String com o caminho absoluto ou relativo do arquivo de malha. - `bytes`: Os bytes do arquivo de malha. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de malha de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`). **Retorna:** `trimesh.Trimesh` ou `trimesh.Scene` Decodificar arquivo de malha de exemplo. #### embed_storage[[datasets.Mesh.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L215) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se os dados de arquivos locais devem ser incorporados no array. remote_files (`bool`, padrão `True`) : Se os dados de arquivos remotos devem ser incorporados no array. **Retorna:** `pa.StructArray` Array no tipo de armazenamento Mesh arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incorpore arquivos de malha no array Arrow. #### encode_example[[datasets.Mesh.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('trimesh.Trimesh'), ForwardRef('trimesh.Scene')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L57) **Parâmetros:** value (`str`, `bytes`, `dict`, `trimesh.Trimesh` ou `trimesh.Scene`) : Dados passados como entrada para o recurso Mesh. **Retorna:** `dict` com os campos "path" e "bytes" Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.Mesh.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/mesh.py#L149) Se estiver no estado decodificável, retorne o próprio recurso; caso contrário, achate o recurso em um dicionário. ### Json[[datasets.Json]] #### datasets.Json[[datasets.Json]] ```python datasets.Json(decode: bool = True, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1258) Tipo de recurso para objetos JSON. Por baixo dos panos, os objetos são armazenados como strings codificadas em JSON. Exemplo: ```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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/features.py#L1321) **Parâmetros:** storage (`Union[pa.StringArray, pa.IntegerArray]`) : array do PyArrow para converter. **Retorna:** `pa.JsonArray` Array no tipo de armazenamento arrow `Json`. Converte um array Arrow para o tipo de armazenamento Arrow `Json`. ### Pdf[[datasets.Pdf]] #### datasets.Pdf[[datasets.Pdf]] ```python datasets.Pdf(decode: bool = True, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L31) **Parâmetros:** decode (`bool`, padrão `True`) : Se deve decodificar os dados do pdf. Se `False`, retorna o dicionário subjacente no formato `{"path": pdf_path, "bytes": pdf_bytes}`. **Experimental.** O recurso `Feature` de Pdf para ler documentos em pdf a partir de um arquivo pdf. Input: O recurso Pdf aceita como entrada: - Uma `str`: caminho absoluto para o arquivo pdf (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo pdf (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo pdf em um repositório de dataset. - `bytes`: Bytes do arquivo pdf. Isso é útil para arquivos arquivados com acesso sequencial. - Um `pdfplumber.pdf.PDF`: objeto pdf do pdfplumber. Exemplos: ```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"] >>> 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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L183) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.ListArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento Pdf arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Converte um array Arrow para o tipo de armazenamento Arrow do Pdf. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento pyarrow do Pdf são: - `pa.string()` - deve conter os dados "path" - `pa.binary()` - deve conter os bytes da imagem - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa - `pa.list(*)` - deve conter os dados do array pdf #### decode_example[[datasets.Pdf.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L113) **Parâmetros:** value (`str` ou `dict`) : Uma string com o caminho absoluto do arquivo pdf, um dicionário com as chaves: - `path`: String com o caminho absoluto ou relativo do arquivo pdf. - `bytes`: Os bytes do arquivo pdf. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos pdf de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`). **Retorna:** `pdfplumber.pdf.PDF` Decodifique o arquivo de exemplo em PDF para dados de 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L220) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos locais no array remote_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos remotos no array. Por exemplo, arquivos com caminhos que começam com hf:// ou https:// **Retorna:** `pa.StructArray` Array no tipo de armazenamento PDF arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incorpore arquivos PDF no array Arrow. #### encode_example[[datasets.Pdf.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('pdfplumber.pdf.PDF')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L78) **Parâmetros:** value (`str`, `bytes`, `pdfplumber.pdf.PDF` ou `dict`) : Dados passados como entrada para o recurso Pdf. **Retorna:** `dict` com os campos "path" e "bytes" Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.Pdf.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/pdf.py#L170) Se estiver no estado decodificável, retorne o próprio recurso; caso contrário, achate o recurso em um dicionário. ### Nifti[[datasets.Nifti]] #### datasets.Nifti[[datasets.Nifti]] ```python datasets.Nifti(decode: bool = True, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L64) **Parâmetros:** decode (`bool`, padrão `True`) : Se deve decodificar os dados NIfTI. Se `False`, uma string com os bytes é retornada. `decode=False` não é suportado ao decodificar exemplos. **Experimental.** `Feature` Nifti para ler arquivos de neuroimagem NIfTI. Input: O recurso Nifti aceita como entrada: - Uma `str`: Caminho absoluto para o arquivo NIfTI (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo NIfTI (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo NIfTI em um repositório de dataset. - `bytes`: Bytes do arquivo NIfTI. Isso é útil para arquivos arquivados com acesso sequencial. - Um objeto de imagem `nibabel` (por exemplo, `nibabel.nifti1.Nifti1Image`). Exemplos: ```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"] >>> 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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L298) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray, pa.BinaryArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento Nifti arrow, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Converte um array Arrow para o tipo de armazenamento Nifti arrow. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento Nifti pyarrow são: - `pa.string()` - deve conter os dados "path" - `pa.binary()` - deve conter os bytes do NIfTI - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa #### decode_example[[datasets.Nifti.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L150) **Parâmetros:** value (`str` ou `dict`) : Uma string com o caminho absoluto do arquivo NIfTI, um dicionário com as chaves: - `path`: String com o caminho absoluto ou relativo do arquivo NIfTI. - `bytes`: Os bytes do arquivo NIfTI. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos NIfTI de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`). **Retorna:** objetos `nibabel.Nifti1Image` Decodifique o arquivo NIfTI de exemplo em um objeto de imagem do 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L216) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos locais no array remote_files (`bool`, padrão `True`) : Se deve incorporar os dados de arquivos remotos no array. Por exemplo, arquivos com caminhos que começam com hf:// ou https:// **Retorna:** `pa.StructArray` Array no tipo de armazenamento arrow do NifTI, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Incorpore arquivos NifTI no array Arrow. #### encode_example[[datasets.Nifti.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('nib.Nifti1Image')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L110) **Parâmetros:** value (`str`, `bytes`, `nibabel.Nifti1Image` ou `dict`) : Dados passados como entrada para o recurso Nifti. **Retorna:** `dict` com os campos "path" e "bytes" Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.Nifti.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/nifti.py#L285) Se estiver no estado decodificável, retorne o próprio recurso; caso contrário, achate o recurso em um dicionário. ### BioSequence[[datasets.BioSequence]] #### datasets.BioSequence[[datasets.BioSequence]] ```python datasets.BioSequence(format: str = 'fasta', decode: bool = True, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L44) **Parâmetros:** format (`str`, padrão `"fasta"`) : Nome do formato da sequência, conforme interpretado por `Bio.SeqIO`. Valores comuns são `"fasta"`, `"fastq"` e `"genbank"`. decode (`bool`, padrão `True`) : Se deve decodificar os dados da sequência. Se `False`, retorna o dicionário subjacente no formato `{"path": path, "bytes": bytes}`. **Experimental.** `Feature` de BioSequence para ler registros de sequências biológicas de um arquivo de sequência. Um arquivo de sequência contém um ou mais registros de resíduos com seus identificadores e anotações. FASTA, FASTQ e GenBank têm a mesma estrutura nesse nível, diferindo apenas no parser utilizado, de modo que `format` seleciona o parser em vez do tipo. Input: O recurso BioSequence aceita como entrada: - Uma `str`: caminho absoluto para o arquivo de sequência (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo de sequência (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo de sequência em um repositório de dataset. - `bytes`: Bytes do arquivo de sequência. Isso é útil para arquivos arquivados com acesso sequencial. - Um `Bio.SeqRecord.SeqRecord`: registro de sequência do biopython. Exemplos: ```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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L199) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento arrow BioSequence, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Converte um array Arrow para o tipo de armazenamento arrow BioSequence. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento pyarrow BioSequence são: - `pa.string()` - deve conter os dados "path" - `pa.binary()` - deve conter os bytes do arquivo - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa #### decode_example[[datasets.BioSequence.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L132) **Parâmetros:** value (`str` ou `dict`) : Uma string com o caminho absoluto do arquivo, ou um dicionário com as chaves: - `path`: String com o caminho absoluto ou relativo do arquivo. - `bytes`: Os bytes do arquivo. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`). **Retorna:** `Bio.SeqRecord.SeqRecord` Decodifique o arquivo de sequência de exemplo em um registro do biopython. Um arquivo pode conter muitos registros; isso retorna o primeiro, pois uma linha é um registro. Use os carregadores de sequência empacotados para expandir um arquivo com múltiplos registros em uma linha por registro. #### embed_storage[[datasets.BioSequence.embed_storage]] ```python embed_storage(storage: StructArray, token_per_repo_id = None, local_files: bool = True, remote_files: bool = True) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L219) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se os dados de arquivos locais devem ser incorporados no array. remote_files (`bool`, padrão `True`) : Se os dados de arquivos remotos devem ser incorporados no array. **Retorna:** `pa.StructArray` Array no tipo de armazenamento arrow BioSequence. Incorpore os arquivos de sequência no array Arrow. #### encode_example[[datasets.BioSequence.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('SeqRecord')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L99) **Parâmetros:** value (`str`, `bytes`, `Bio.SeqRecord.SeqRecord` ou `dict`) : Dados passados como entrada para o recurso BioSequence. **Retorna:** `dict` com os campos "path" e "bytes" Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.BioSequence.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_sequence.py#L186) Se estiver no estado decodificável, retorne o próprio recurso; caso contrário, achate o recurso em um dicionário. ### BioStructure[[datasets.BioStructure]] #### datasets.BioStructure[[datasets.BioStructure]] ```python datasets.BioStructure(format: str = 'pdb', decode: bool = True, id: typing.Optional[str] = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L48) **Parâmetros:** format (`str`, padrão `"pdb"`) : Formato da estrutura, seja `"pdb"` ou `"mmcif"`. decode (`bool`, padrão `True`) : Se deve decodificar os dados da estrutura. Se `False`, retorna o dicionário subjacente no formato `{"path": path, "bytes": bytes}`. **Experimental.** O recurso `Feature` do BioStructure para ler estruturas de macromoléculas de um arquivo de estrutura. Um arquivo de estrutura contém as coordenadas tridimensionais dos átomos de uma molécula, agrupados em cadeias e resíduos. PDB e mmCIF descrevem os mesmos objetos e diferem apenas no parser utilizado, portanto `format` seleciona o parser em vez do tipo. Input: O recurso BioStructure aceita como entrada: - Uma `str`: caminho absoluto para o arquivo de estrutura (ou seja, o acesso aleatório é permitido). - Um `pathlib.Path`: caminho para o arquivo de estrutura (ou seja, o acesso aleatório é permitido). - Um `dict` com as chaves: - `path`: String com o caminho relativo do arquivo de estrutura em um repositório de dataset. - `bytes`: Bytes do arquivo de estrutura. Isso é útil para arquivos arquivados com acesso sequencial. - Uma `Bio.PDB.Structure.Structure`: estrutura do biopython. Exemplos: ```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"] >>> 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]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L204) **Parâmetros:** storage (`Union[pa.StringArray, pa.StructArray]`) : array do PyArrow para converter. **Retorna:** `pa.StructArray` Array no tipo de armazenamento arrow BioStructure, ou seja, `pa.struct({"bytes": pa.binary(), "path": pa.string()})`. Converte um array Arrow para o tipo de armazenamento arrow do BioStructure. Os tipos Arrow que podem ser convertidos para o tipo de armazenamento pyarrow do BioStructure são: - `pa.string()` - deve conter os dados "path" - `pa.binary()` - deve conter os bytes do arquivo - `pa.struct({"bytes": pa.binary()})` - `pa.struct({"path": pa.string()})` - `pa.struct({"bytes": pa.binary(), "path": pa.string()})` - a ordem não importa #### decode_example[[datasets.BioStructure.decode_example]] ```python decode_example(value: dict, token_per_repo_id = None) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L138) **Parâmetros:** value (`str` ou `dict`) : Uma string com o caminho absoluto do arquivo, ou um dicionário com as chaves: - `path`: String com o caminho absoluto ou relativo do arquivo. - `bytes`: Os bytes do arquivo. token_per_repo_id (`dict`, *opcional*) : Para acessar e decodificar arquivos de repositórios privados no Hub, você pode passar um dicionário repo_id (`str`) -> token (`bool` ou `str`). **Retorna:** `Bio.PDB.Structure.Structure` Decodifique o arquivo de exemplo de estrutura em uma estrutura 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) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L224) **Parâmetros:** storage (`pa.StructArray`) : array do PyArrow para incorporar. token_per_repo_id (`dict`, opcional) : Dicionário repo_id -> token para buscar os bytes dos arquivos. local_files (`bool`, padrão `True`) : Se os dados de arquivos locais devem ser incorporados no array. remote_files (`bool`, padrão `True`) : Se os dados de arquivos remotos devem ser incorporados no array. **Retorna:** `pa.StructArray` Array no tipo de armazenamento arrow do BioStructure. Incorpore os arquivos de estrutura no array Arrow. #### encode_example[[datasets.BioStructure.encode_example]] ```python encode_example(value: typing.Union[str, bytes, bytearray, dict, ForwardRef('Structure')]) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L105) **Parâmetros:** value (`str`, `bytes`, `Bio.PDB.Structure.Structure` ou `dict`) : Dados passados como entrada para o recurso BioStructure. **Retorna:** `dict` com os campos "path" e "bytes" Codifique o exemplo em um formato para Arrow. #### flatten[[datasets.BioStructure.flatten]] ```python flatten() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/features/bio_structure.py#L191) Se estiver no estado decodificável, retorne o próprio recurso; caso contrário, achate o recurso em um dicionário. ## Sistemas de arquivos[[datasets.filesystems.is_remote_filesystem]] #### datasets.filesystems.is_remote_filesystem[[datasets.filesystems.is_remote_filesystem]] ```python datasets.filesystems.is_remote_filesystem(fs: AbstractFileSystem) ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/filesystems/__init__.py#L33) **Parâmetros:** fs (`fsspec.spec.AbstractFileSystem`) : Uma superclasse abstrata para sistemas de arquivos pythonic, por exemplo, `fsspec.filesystem('file')` ou `s3fs.S3FileSystem`. Verifica se `fs` é um sistema de arquivos remoto. ## Impressão digital[[datasets.fingerprint.Hasher]] #### datasets.fingerprint.Hasher[[datasets.fingerprint.Hasher]] ```python datasets.fingerprint.Hasher() ``` [Fonte](https://github.com/huggingface/datasets/blob/5.2.0/src/datasets/fingerprint.py#L196) Hasher que aceita objetos Python como entradas.