# Conjuntos de dados

`LeRobotDataset` é o formato que todos os scripts do LeRobot leem e gravam. Ele é consciente de episódios, decodifica observações de vídeo sob demanda e faz round-trip para o Hugging Face Hub.

Consulte [Usando LeRobotDataset](../lerobot-dataset-v3) para o formato e as operações comuns, [Portando Conjuntos de Dados Grandes](../porting_datasets_v3) para migração e [Ferramentas](../tools) para a CLI.

## LeRobotDataset[[lerobot.datasets.LeRobotDataset]]

#### lerobot.datasets.LeRobotDataset[[lerobot.datasets.LeRobotDataset]]

```python
lerobot.datasets.LeRobotDataset(repo_id: str, root: str | pathlib.Path | None = None, episodes: list[int] | None = None, episode_filter: collections.abc.Callable[[dict], bool] | None = None, image_transforms: collections.abc.Callable | None = None, delta_timestamps: dict[str, list[float]] | None = None, tolerance_s: float = 0.0001, revision: str | None = None, force_cache_sync: bool = False, download_videos: bool = True, video_backend: str | None = None, return_uint8: bool = False, depth_output_unit: str = 'mm', batch_encoding_size: int = 1, rgb_encoder: lerobot.configs.video.RGBEncoderConfig | None = None, depth_encoder: lerobot.configs.video.DepthEncoderConfig | None = None, encoder_threads: int | None = None, streaming_encoding: bool = False, encoder_queue_maxsize: int = 30, repo_type: str = 'dataset', token: str | bool | None = None, video_decoder_cache_size: int | None = None, storage_options: dict[str, str] | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L52)

#### add_frame[[lerobot.datasets.LeRobotDataset.add_frame]]

```python
add_frame(frame: dict)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L516)

**Parâmetros:**

frame : Dict que mapeia os nomes dos recursos para seus valores neste frame. Deve incluir uma chave `'task'`. Tensors do Torch são convertidos para numpy.

**Exceções:** `RuntimeError`

- `RuntimeError` -- Se o conjunto de dados for somente leitura (sem escritor).

Adicione um único quadro ao buffer do episódio atual.

Delega para `DatasetWriter.add_frame`. O dataset deve estar em modo de escrita (criado via `create` ou `resume`).

#### clear_episode_buffer[[lerobot.datasets.LeRobotDataset.clear_episode_buffer]]

```python
clear_episode_buffer(delete_images: bool = True)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L548)

**Parâmetros:**

delete_images : Se `True`, também remove os arquivos de imagem temporários gravados no disco para o episódio atual.

**Exceções:** `RuntimeError`

- `RuntimeError` -- Se o conjunto de dados for somente leitura (sem escritor).

Descarte o buffer do episódio atual sem salvar.

Delega para `DatasetWriter.clear_episode_buffer`. Útil para descartar um episódio de gravação falho ou interrompido.

#### clear_image_transforms[[lerobot.datasets.LeRobotDataset.clear_image_transforms]]

```python
clear_image_transforms()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L655)

Remove a transformação aplicada às observações visuais.

#### criar[[lerobot.datasets.LeRobotDataset.create]]

```python
create(repo_id: str, fps: int, features: dict, root: str | pathlib.Path | None = None, robot_type: str | None = None, use_videos: bool = True, tolerance_s: float = 0.0001, image_writer_processes: int = 0, image_writer_threads: int = 0, video_backend: str | None = None, batch_encoding_size: int = 1, rgb_encoder: lerobot.configs.video.RGBEncoderConfig | None = None, depth_encoder: lerobot.configs.video.DepthEncoderConfig | None = None, metadata_buffer_size: int = 10, streaming_encoding: bool = False, encoder_queue_maxsize: int = 30, encoder_threads: int | None = None, video_files_size_in_mb: int | None = None, data_files_size_in_mb: int | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L782)

**Parâmetros:**

repo_id : Identificador do repositório, normalmente `'&amp;lcub;hf_user}/&amp;lcub;dataset_name}'`.

fps : Quadros por segundo usados durante a coleta de dados.

features : Dicionário de especificação de recursos que mapeia os nomes dos recursos para seus metadados de tipo/formato.

root : Diretório local para armazenamento do conjunto de dados. O padrão é `$HF_LEROBOT_HOME/&amp;lcub;repo_id}`.

robot_type : String opcional do tipo de robô armazenada nos metadados.

use_videos : Se `True`, as modalidades visuais são armazenadas como vídeos MP4. Se `False`, são armazenadas como imagens.

tolerance_s : Tolerância de sincronização de timestamp em segundos.

image_writer_processes : Número de subprocessos para escrita assíncrona de imagens. `0` significa usar apenas threads.

image_writer_threads : Número de threads para escrita assíncrona de imagens.

video_backend : Backend de decodificação de vídeo (usado ao ler de volta).

batch_encoding_size : Número de episódios a acumular antes de codificar os vídeos em lote. `1` significa codificar imediatamente.

rgb_encoder : Configurações do codificador de vídeo para câmeras (código, qualidade, etc.). Quando `None`, `rgb_encoder_defaults()` é usado.

depth_encoder : Configurações do codificador de vídeo para câmeras de profundidade (código, qualidade, etc.). Quando `None`, `depth_encoder_defaults()` é usado.

encoder_threads : Número de threads do codificador (global). `None` deixa o codec decidir.

metadata_buffer_size : Número de registros de metadados de episódios a serem armazenados em buffer antes de serem gravados no parquet.

streaming_encoding : Se `True`, codifique os quadros do vídeo em tempo real durante a captura, em vez de gravar as imagens primeiro.

encoder_queue_maxsize : Máximo de quadros em buffer por câmera ao usar codificação em streaming.

**Retorna:**

Um novo `LeRobotDataset` em modo de escrita.

Crie um novo LeRobotDataset do zero para gravar dados.

Retorna um dataset em modo de escrita com um `DatasetWriter` ativo. Use `add_frame` / `save_episode` para preenchê-lo e, em seguida, `finalize` quando terminar.

#### finalize[[lerobot.datasets.LeRobotDataset.finalize]]

```python
finalize()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L570)

Descarte todo o trabalho pendente e feche os escritores.

Deve ser chamado após a coleta/conversão de dados; caso contrário, os metadados do rodapé não serão gravados nos arquivos parquet e o conjunto de dados ficará inválido.

Idempotente — seguro para chamar várias vezes. O __del__ do DatasetWriter atua como uma rede de segurança caso isso nunca seja chamado explicitamente.

#### get_raw_item[[lerobot.datasets.LeRobotDataset.get_raw_item]]

```python
get_raw_item(idx)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L631)

Obtenha um quadro bruto sem as transformações de imagem aplicadas.

Diferentemente de `__getitem__`, este retorna a linha bruta do dataset HF no índice fornecido, sem expansão de delta-timestamp, decodificação de vídeo ou transformações de imagem.

#### has_pending_frames[[lerobot.datasets.LeRobotDataset.has_pending_frames]]

```python
has_pending_frames()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L563)

Verifique se há quadros não salvos no buffer de episódios.

#### push_to_hub[[lerobot.datasets.LeRobotDataset.push_to_hub]]

```python
push_to_hub(branch: str | None = None, tags: list | None = None, license: str | None = 'apache-2.0', tag_version: bool = True, push_videos: bool = True, private: bool | None = None, allow_patterns: list[str] | str | None = None, upload_large_folder: bool = False, **card_kwargs)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L663)

**Parâmetros:**

branch : Branch opcional para o push. Criada a partir da revisão atual, caso não exista.

tags : Lista opcional de tags para o cartão do conjunto de dados.

license : Identificador de licença para o cartão do conjunto de dados.

tag_version : Se `True`, cria uma tag Git para a versão atual da base de código.

push_videos : Se `False`, ignore o upload do diretório `videos/`.

private : Se `True`, cria um repositório privado. Se `None` (padrão), usa o padrão da organização no Hub (afeta apenas organizações).

allow_patterns : Padrões glob que restringem quais arquivos serão enviados.

upload_large_folder : Mantido para compatibilidade com versões anteriores e ignorado. `upload_folder` lida com conjuntos de dados de todos os tamanhos.

- ****card_kwargs** : Argumentos de palavra-chave adicionais encaminhados para a criação do card do dataset.

Envie o conjunto de dados para o Hugging Face Hub.

Cria o repositório se ele não existir, faz o upload de todos os arquivos do conjunto de dados (opcionalmente excluindo vídeos), gera um cartão do conjunto de dados e marca a revisão com a versão atual da base de código.

#### retomar[[lerobot.datasets.LeRobotDataset.resume]]

```python
resume(repo_id: str, root: str | pathlib.Path | None = None, tolerance_s: float = 0.0001, revision: str | None = None, force_cache_sync: bool = False, video_backend: str | None = None, batch_encoding_size: int = 1, rgb_encoder: lerobot.configs.video.RGBEncoderConfig | None = None, depth_encoder: lerobot.configs.video.DepthEncoderConfig | None = None, encoder_threads: int | None = None, image_writer_processes: int = 0, image_writer_threads: int = 0, streaming_encoding: bool = False, encoder_queue_maxsize: int = 30, token: str | bool | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L896)

**Parâmetros:**

repo_id : Identificador do repositório do conjunto de dados existente.

root : Diretório local do conjunto de dados. Quando fornecido, os downloads do Hub são materializados diretamente neste diretório. Quando omitido, os downloads do Hub usam um cache de snapshot seguro para revisões sob `$HF_LEROBOT_HOME/hub`.

tolerance_s : Tolerância de sincronização de timestamp em segundos.

revision : Revisão do Git (branch, tag ou hash de commit). O padrão é a tag da versão atual da base de código.

force_cache_sync : Se `True`, baixa novamente os metadados do Hub, mesmo que um cache local exista.

video_backend : Backend de decodificação de vídeo para leitura de dados.

batch_encoding_size : Número de episódios a acumular antes de codificar os vídeos em lote.

rgb_encoder : Configurações do codificador de vídeo para câmeras (código, qualidade, etc.). Quando `None`, `rgb_encoder_defaults()` é usado.

depth_encoder : Configurações do codificador de vídeo para câmeras de profundidade (código, qualidade, etc.). Quando `None`, `depth_encoder_defaults()` é usado.

encoder_threads : Número de threads do codificador (global). `None` deixa o codec decidir.

image_writer_processes : Subprocessos para escrita assíncrona de imagens.

image_writer_threads : Threads para escrita assíncrona de imagens.

streaming_encoding : Se `True`, codifica o vídeo em tempo real durante a captura.

encoder_queue_maxsize : Máximo de quadros em buffer por câmera para streaming.

token : Token de autenticação usado quando os metadados precisam ser baixados do Hub. O token não é retido na instância do dataset.

**Retorna:**

Um `LeRobotDataset` em modo de escrita, pronto para adicionar episódios.

Retomar a gravação em um conjunto de dados existente.

Carrega metadados de um conjunto de dados existente (local ou Hub) e cria um `DatasetWriter` para adicionar novos episódios. O conjunto de dados subjacente do HF não é carregado até que `finalize` seja chamado e os dados sejam lidos em seguida.

#### save_episode[[lerobot.datasets.LeRobotDataset.save_episode]]

```python
save_episode(episode_data: dict | None = None, parallel_encoding: bool = True)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L531)

**Parâmetros:**

episode_data : Dicionário de episódio pré-construído opcional. Se `None`, usa o buffer de episódio interno preenchido por `add_frame`.

parallel_encoding : Se `True` e houver múltiplas câmeras, codifique os vídeos em paralelo usando um pool de processos.

**Exceções:** `RuntimeError`

- `RuntimeError` -- Se o conjunto de dados for somente leitura (sem escritor).

Salve o buffer do episódio atual no disco.

Delega para `DatasetWriter.save_episode`. Codifica vídeos, grava dados parquet e atualiza metadados. O buffer de episódios é reiniciado em seguida.

#### select_columns[[lerobot.datasets.LeRobotDataset.select_columns]]

```python
select_columns(column_names: str | list[str])
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L623)

Selecione colunas específicas do conjunto de dados subjacente.

Útil para extrair sequências de ações durante a reprodução sem carregar todos os recursos. Retorna um `datasets.Dataset` contendo apenas as colunas solicitadas.

#### set_image_transforms[[lerobot.datasets.LeRobotDataset.set_image_transforms]]

```python
set_image_transforms(image_transforms: collections.abc.Callable | None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/lerobot_dataset.py#L650)

Substitua a transformação aplicada às observações visuais.

## LeRobotDatasetMetadata[[lerobot.datasets.LeRobotDatasetMetadata]]

#### lerobot.datasets.LeRobotDatasetMetadata[[lerobot.datasets.LeRobotDatasetMetadata]]

```python
lerobot.datasets.LeRobotDatasetMetadata(repo_id: str, root: str | pathlib.Path | None = None, revision: str | None = None, force_cache_sync: bool = False, metadata_buffer_size: int = 10, repo_type: typing.Literal['dataset', 'bucket'] = 'dataset', token: str | bool | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L67)

Contêiner de metadados para um dataset LeRobot.

Gerencia os arquivos parquet `info.json`, `stats.json`, `tasks.parquet` e `episodes/` que descrevem a estrutura, o conteúdo e as estatísticas de um conjunto de dados.

#### criar[[lerobot.datasets.LeRobotDatasetMetadata.create]]

```python
create(repo_id: str, fps: int, features: dict, robot_type: str | None = None, root: str | pathlib.Path | None = None, use_videos: bool = True, metadata_buffer_size: int = 10, chunks_size: int | None = None, data_files_size_in_mb: int | None = None, video_files_size_in_mb: int | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L797)

**Parâmetros:**

repo_id : Identificador do repositório (por exemplo, `'user/my_dataset'`).

fps : Quadros por segundo usados durante a coleta de dados.

features : Dicionário de especificação de recursos que mapeia os nomes dos recursos para seus metadados de tipo/formato.

robot_type : String opcional do tipo de robô armazenada nos metadados.

root : Diretório local para o conjunto de dados. O padrão é `$HF_LEROBOT_HOME/&amp;lcub;repo_id}`. Não deve existir previamente.

use_videos : Se `True`, as modalidades visuais são codificadas como vídeos MP4.

metadata_buffer_size : Número de registros de metadados de episódios a serem armazenados em buffer antes de serem gravados no parquet.

chunks_size : Número máximo de arquivos por diretório de chunk. `None` usa o padrão.

data_files_size_in_mb : Tamanho máximo do arquivo parquet em MB. `None` usa o padrão.

video_files_size_in_mb : Tamanho máximo do arquivo de vídeo em MB. `None` usa o padrão.

**Retorna:**

Uma nova instância de `LeRobotDatasetMetadata`.

Crie metadados para um novo dataset LeRobot do zero.

Inicializa o arquivo `info.json` no disco com o esquema de recursos e as configurações do conjunto de dados fornecidos. Nenhum dado de episódio é gravado ainda.

#### ensure_readable[[lerobot.datasets.LeRobotDatasetMetadata.ensure_readable]]

```python
ensure_readable()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L225)

Garanta que os metadados sejam totalmente carregados para operações de leitura.

Idempotente — quando os metadados já estão na memória, isso é apenas uma verificação de `is None`. Chame isso antes de transicionar do modo de escrita para o modo de leitura na mesma instância.

#### filter_episodes[[lerobot.datasets.LeRobotDatasetMetadata.filter_episodes]]

```python
filter_episodes(predicate: Callable, candidates: list[int] | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L235)

**Parâmetros:**

predicate : Predicado sobre linhas de metadados por episódio usado para selecionar episódios.

candidates : Lista opcional de índices de episódios para restringir a avaliação.

**Retorna:**

Lista de índices de episódios ordenados que satisfazem o predicado.

Filtre episódios cujo metadados satisfazem um predicado dado.

#### finalize[[lerobot.datasets.LeRobotDatasetMetadata.finalize]]

```python
finalize()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L202)

Descarregue o buffer de metadados e feche o escritor parquet.

Idempotente — seguro para chamar várias vezes.

#### get_chunk_settings[[lerobot.datasets.LeRobotDatasetMetadata.get_chunk_settings]]

```python
get_chunk_settings()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L774)

**Retorna:**

Dicionário contendo chunks_size, data_files_size_in_mb e video_files_size_in_mb.

Obtenha as configurações atuais de tamanho de bloco e de arquivo.

#### get_data_file_path[[lerobot.datasets.LeRobotDatasetMetadata.get_data_file_path]]

```python
get_data_file_path(ep_index: int)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L312)

**Parâmetros:**

ep_index : Índice do episódio com base zero.

**Retorna:**

Caminho para o arquivo parquet contendo os dados deste episódio.

**Exceções:** `IndexError`

- `IndexError` -- Se `ep_index` estiver fora do intervalo.

Retorna o caminho relativo do arquivo parquet para o índice de episódio fornecido.

#### get_task_index[[lerobot.datasets.LeRobotDatasetMetadata.get_task_index]]

```python
get_task_index(task: str)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L533)

Dada uma tarefa em linguagem natural, retorna seu task_index se a tarefa já existir no conjunto de dados; caso contrário, retorna None.

#### get_video_file_path[[lerobot.datasets.LeRobotDatasetMetadata.get_video_file_path]]

```python
get_video_file_path(ep_index: int, vid_key: str)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L336)

**Parâmetros:**

ep_index : Índice do episódio com base zero.

vid_key : Chave de recurso que identifica o fluxo de vídeo (por exemplo, `'observation.images.laptop'`).

**Retorna:**

Caminho para o arquivo de vídeo contendo os quadros deste episódio.

**Exceções:** `IndexError` ou `ValueError`

- `IndexError` -- Se `ep_index` estiver fora do intervalo.
- `ValueError` -- Se o conjunto de dados não armazenar vídeos (sem o modelo `video_path`).

Retorna o caminho relativo do arquivo de vídeo para o episódio e a chave de vídeo fornecidos.

#### rescale_depth_stats[[lerobot.datasets.LeRobotDatasetMetadata.rescale_depth_stats]]

```python
rescale_depth_stats(output_unit: str)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L416)

Redimensione as estatísticas do recurso de profundidade no local, de sua unidade registrada para `output_unit`.

As estatísticas de profundidade são armazenadas na unidade em que os quadros foram gravados (`features[key]["info"]["depth_unit"]`), enquanto os quadros são retornados em `output_unit` na leitura. Isso converte as entradas de estatísticas com unidade para que as estatísticas correspondam aos quadros vistos pelos consumidores.

#### save_episode[[lerobot.datasets.LeRobotDatasetMetadata.save_episode]]

```python
save_episode(episode_index: int, episode_length: int, episode_tasks: list, episode_stats: dict, episode_metadata: dict)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L643)

**Parâmetros:**

episode_index : Índice base zero do episódio sendo salvo.

episode_length : Número de quadros neste episódio.

episode_tasks : Lista de descrições de tarefas para este episódio.

episode_stats : Estatísticas por recurso para este episódio.

episode_metadata : Metadados adicionais (índices de chunk/arquivo, intervalos de quadros, timestamps de vídeo, etc.).

Persista os metadados do episódio, atualize as informações do conjunto de dados e agregue as estatísticas.

Escreve os metadados do episódio no escritor parquet em buffer, incrementa os contadores totais de episódios/quadros em `info.json` e mescla as estatísticas do episódio nas estatísticas acumuladas do conjunto de dados.

#### save_episode_tasks[[lerobot.datasets.LeRobotDatasetMetadata.save_episode_tasks]]

```python
save_episode_tasks(tasks: list)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L543)

**Parâmetros:**

tasks : Lista de descrições de tarefas únicas em linguagem natural.

**Exceções:** `ValueError`

- `ValueError` -- Se `tasks` contiver duplicados.

Registre as tarefas para o episódio atual e persista no disco.

Novas tarefas que ainda não existem no conjunto de dados recebem índices de tarefa sequenciais e são adicionados ao arquivo parquet de tarefas.

#### update_chunk_settings[[lerobot.datasets.LeRobotDatasetMetadata.update_chunk_settings]]

```python
update_chunk_settings(chunks_size: int | None = None, data_files_size_in_mb: int | None = None, video_files_size_in_mb: int | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L739)

**Parâmetros:**

chunks_size : Número máximo de arquivos por diretório de chunk. Se for None, mantém o valor atual.

data_files_size_in_mb : Tamanho máximo para arquivos de dados parquet em MB. Se for None, mantém o valor atual.

video_files_size_in_mb : Tamanho máximo para arquivos de vídeo em MB. Se for None, mantém o valor atual.

Atualize as configurações de tamanho de chunk e de arquivo após a criação do conjunto de dados.

Isso permite que os usuários personalizem a organização do armazenamento sem modificar o construtor. Essas configurações controlam como os episódios são divididos em blocos e o tamanho máximo que os arquivos podem atingir antes de novos arquivos serem criados.

#### update_video_info[[lerobot.datasets.LeRobotDatasetMetadata.update_video_info]]

```python
update_video_info(video_key: str | None = None, video_encoder: lerobot.configs.video.VideoEncoderConfig | None = None, preserve_keys: collections.abc.Iterable[str] | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/dataset_metadata.py#L685)

**Parâmetros:**

video_key : Se fornecido, atualiza apenas esta chave de vídeo. Caso contrário, atualiza todas as chaves de vídeo no conjunto de dados.

video_encoder : Configuração do encoder usada para produzir os vídeos. Quando fornecida, seus campos são registrados como entradas `video.&amp;lt;field>` junto com as entradas derivadas do stream `video.*` (veja `get_video_info`).

preserve_keys : Chaves cujos valores existentes são mantidos em vez de serem recalculados. `None` (padrão) recalcula todas as chaves.

Preencha ou atualize as informações de vídeo por recurso em `info.json`.

Aviso: esta função grava informações dos vídeos do primeiro episódio, assumindo implicitamente que todos os vídeos foram codificados da mesma forma. Além disso, isso significa que ela assume que o primeiro episódio existe.

Sempre reanalisar os vídeos e sobrescrever as informações existentes para cada chave recalculada. `preserve_keys` lista as chaves cujos valores existentes devem ser mantidos (por exemplo, entradas intrínsecas aos dados, como `is_depth_map` e os parâmetros de quantização de profundidade) em vez de serem recalculadas.

## MultiLeRobotDataset[[lerobot.datasets.MultiLeRobotDataset]]

#### lerobot.datasets.MultiLeRobotDataset[[lerobot.datasets.MultiLeRobotDataset]]

```python
lerobot.datasets.MultiLeRobotDataset(repo_ids: list, root: str | pathlib.Path | None = None, episodes: dict | None = None, image_transforms: collections.abc.Callable | None = None, delta_timestamps: dict[str, list[float]] | None = None, tolerances_s: dict | None = None, download_videos: bool = True, video_backend: str | None = None, token: str | bool | None = None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/multi_dataset.py#L34)

Um conjunto de dados composto por múltiplos `LeRobotDataset` subjacentes.

Os `LeRobotDataset` subjacentes são efetivamente concatenados, e esta classe adota grande parte da estrutura de API do `LeRobotDataset`.

#### clear_image_transforms[[lerobot.datasets.MultiLeRobotDataset.clear_image_transforms]]

```python
clear_image_transforms()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/multi_dataset.py#L111)

Remova a transformação deste conjunto de dados e de seus filhos.

#### set_image_transforms[[lerobot.datasets.MultiLeRobotDataset.set_image_transforms]]

```python
set_image_transforms(image_transforms: collections.abc.Callable | None)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/multi_dataset.py#L103)

Substitua a transformação para este conjunto de dados e seus descendentes.

## StreamingLeRobotDataset[[lerobot.datasets.StreamingLeRobotDataset]]

#### lerobot.datasets.StreamingLeRobotDataset[[lerobot.datasets.StreamingLeRobotDataset]]

```python
lerobot.datasets.StreamingLeRobotDataset(repo_id: str, root: str | pathlib.Path | None = None, episodes: list[int] | None = None, image_transforms: collections.abc.Callable[[torch.Tensor], torch.Tensor] | None = None, delta_timestamps: dict[str, list[float]] | None = None, tolerance_s: float = 0.0001, revision: str | None = None, force_cache_sync: bool = False, streaming: bool | None = None, buffer_size: int = 1000, max_num_shards: int = 16, seed: int = 42, rng: numpy.random._generator.Generator | None = None, shuffle: bool = True, return_uint8: bool = False, depth_output_unit: str = 'mm', video_backend: str | None = None, data_root: str | pathlib.Path | None = None, episode_pool_size: int | None = None, prefetch_episodes: int = 8, byte_budget_gb: float = 8.0, repeat: bool = False, repo_type: typing.Literal['dataset', 'bucket'] = 'dataset', token: str | bool | None = None, decode_threads: int = 2, decoded_queue_size: int = 8, video_decoder_cache_size: int | None = None, native_http_connections: int | None = None, native_http_subranges: int = 1, sidecar_lock_timeout_s: float = 1800, sampling_strategy: lerobot.streaming.episode_pool.StreamingSamplingStrategy | str = <StreamingSamplingStrategy.REMAINING: 'remaining'>)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/streaming_dataset.py#L169)

Leitor de streaming com escopo de episódio para conjuntos de dados LeRobot.

Os metadados são armazenados em cache localmente, enquanto cada rank lê apenas as linhas Parquet e os intervalos de bytes MP4 necessários para os episódios completos que ele possui. Com N workers do DataLoader, cada worker possui uma parte disjunta e equilibrada por quadro dos episódios do rank, com seu próprio pool de episódios e 1/N do orçamento de bytes. Cada processo tem seu próprio GIL do Python, portanto N workers decodificam e montam amostras em paralelo. A posse dos episódios é disjunta e cada quadro selecionado é retornado exatamente uma vez por iteração. Os sidecars MP4 são resolvidos automaticamente e construídos em um cache local com chave de revisão quando ausentes.

Exemplo:

Uso básico:
```python
from lerobot.datasets.streaming_dataset import StreamingLeRobotDataset

# Create a streaming dataset with delta timestamps
delta_timestamps = {
    "observation.image": [-1.0, -0.5, 0.0],  # 1 sec ago, 0.5 sec ago, current
    "action": [0.0, 0.1, 0.2],  # current, 0.1 sec future, 0.2 sec future
}

dataset = StreamingLeRobotDataset(
    repo_id="your-dataset-repo-id",
    delta_timestamps=delta_timestamps,
)

# Iterate over the dataset
for i, item in enumerate(dataset):
    print(f"Sample {i}: Episode {item['episode_index']} Frame {item['frame_index']}")
    # item will contain stacked frames according to delta_timestamps
    if i >= 10:
        break
```

#### load_state_dict[[lerobot.datasets.StreamingLeRobotDataset.load_state_dict]]

```python
load_state_dict(state: dict)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/streaming_dataset.py#L975)

**Parâmetros:**

state (*dict[str, int]*) : Época local da rank, deslocamento de amostra e tamanho do lote. Chaves ausentes têm valores padrão de 0, 0 e 1.

**Exceções:** `ValueError`

- `ValueError` -- Se a época ou o deslocamento for negativo, ou o tamanho do lote não for positivo.

Restaure a posição de âncora do próximo iterador sem buscar as amostras ignoradas.

Nota: A reprodução da ordem das âncoras requer o mesmo conjunto de dados, semente, amostrador, configurações de pool, topologia distribuída e número de workers do DataLoader. Com vários workers, o deslocamento é o deslocamento do rank em lotes inteiros de `batch_size`; cada worker deriva sua própria parte, pois o DataLoader obtém lotes de seus workers em turnos. As transformações aleatórias de imagem não são restauradas por este método.

#### num_episodes_for_rank[[lerobot.datasets.StreamingLeRobotDataset.num_episodes_for_rank]]

```python
num_episodes_for_rank(rank: int, world_size: int)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/streaming_dataset.py#L775)

Retorna o número de episódios inteiros que um rank de treinamento possui.

#### num_frames_for_rank[[lerobot.datasets.StreamingLeRobotDataset.num_frames_for_rank]]

```python
num_frames_for_rank(rank: int, world_size: int, num_workers: int)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/streaming_dataset.py#L762)

Retorne os quadros pertencentes a um único rank de treinamento sob sharding balanceado de episódios inteiros.

#### set_data_parallel_shard[[lerobot.datasets.StreamingLeRobotDataset.set_data_parallel_shard]]

```python
set_data_parallel_shard(rank: int, world_size: int)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/streaming_dataset.py#L671)

Fixe o rank e o tamanho do mundo da paralelização de dados, antes de `torch.distributed` e do ambiente.

Um worker do DataLoader iniciado não possui `torch.distributed` inicializado; os valores chegam até ele por meio de pickling.

#### set_epoch[[lerobot.datasets.StreamingLeRobotDataset.set_epoch]]

```python
set_epoch(epoch: int)
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/streaming_dataset.py#L1005)

**Parâmetros:**

epoch (`int`) : Época de cobertura usada para semear o próximo plano de amostragem quando o embaralhamento está habilitado.

**Exceções:** ``ValueError``

- ``ValueError`` -- Se epoch for negativo.

Selecione um epoch não negativo e redefina o offset de retomada local da rank.

#### state_dict[[lerobot.datasets.StreamingLeRobotDataset.state_dict]]

```python
state_dict()
```

[Fonte](https://github.com/huggingface/lerobot/blob/main/src/lerobot/datasets/streaming_dataset.py#L958)

**Retorna:** `dict[str, int]`

Época, deslocamento da amostra gerada e tamanho do lote de retomada.

Retorna a posição local atual do iterador.

Nota: Com o prefetch do DataLoader, as amostras geradas podem ainda não ter sido consumidas pelo treinamento. O pipeline de treinamento restaura sua posição a partir das etapas concluídas. Com vários workers do DataLoader, cada processo de worker mantém apenas sua própria posição.

