# π₀-FAST (Pi0-FAST) π₀-FAST é um **modelo Vision-Language-Action para controle geral de robôs** que usa a previsão autoregressiva do próximo token para modelar ações contínuas de robôs. ## Visão geral do modelo π₀-FAST combina o poder dos Vision-Language Models com uma nova abordagem de tokenização de ações chamada **FAST (Frequency-space Action Sequence Tokenization)**. Isso permite treinar VLAs autoregressivos em tarefas altamente ágeis que são impossíveis com a discretização padrão baseada em binning, enquanto o treinamento é **até 5x mais rápido** do que abordagens baseadas em difusão, como π₀. An overview of Pi0-FAST ### Por que FAST? As abordagens padrão para a tokenização de ações de robôs utilizam esquemas simples de binning por dimensão e por passo de tempo. Embora sejam aceitáveis para comportamentos simples, essa abordagem se torna rapidamente ineficaz para habilidades complexas e ágeis que exigem precisão e controle de alta frequência. O FAST resolve isso comprimindo sequências de ações usando técnicas de processamento de sinal, resultando em uma sequência densa de tokens de ação que pode ser prevista de forma autoregressiva — assim como tokens de linguagem. ### Como o tokenização FAST funciona O tokenizador FAST comprime sequências de ações por meio das seguintes etapas: 1. **Normalizar**: Pega um trecho de ação contínuo de forma `(H, D)`, onde `H` é o horizonte e `D` é a dimensão da ação. Normaliza usando um dos métodos de normalização suportados (Quantis é recomendado para lidar com valores extremos). 2. **Transformada Cosseno Discreta (DCT)**: Aplique DCT (via scipy) a cada dimensão de ação separadamente. DCT é um algoritmo de compressão comumente usado em codecs de imagem e áudio (JPEG, MP3). 3. **Quantização**: Arredonde e remova coeficientes insignificantes para cada dimensão de ação, produzindo uma matriz de frequência esparsa. 4. **Flatten**: Achatar a matriz em um vetor 1D, com os componentes de baixa frequência primeiro. 5. **Byte Pair Encoding (BPE)**: Treine um tokenizador BPE para comprimir os coeficientes DCT em tokens de ação densos, alcançando tipicamente **10x de compressão** em relação a abordagens anteriores de tokenização. Essa abordagem pode transformar **qualquer VLM existente** em um VLA, treinando-o para prever esses tokens FAST. ## Requisitos de instalação 1. Instale o LeRobot seguindo nosso [Guia de Instalação](./installation). 2. Instale as dependências do π₀-FAST executando: ```bash pip install -e ".[pi]" ``` ## Treinando um Tokenizador FAST Personalizado Você tem duas opções para o tokenizador FAST: 1. **Use o tokenizer pré-treinado**: O tokenizer `lerobot/fast-action-tokenizer` foi treinado em mais de 1 milhão de sequências reais de ações de robôs e funciona como um tokenizer de uso geral. 2. **Treine seu próprio tokenizer**: Para obter o máximo de desempenho no seu conjunto de dados específico, você pode fazer o ajuste fino do tokenizer nos seus próprios dados. ### Treinando o Seu Próprio Tokenizador ```bash lerobot-train-tokenizer \ --repo_id "user/my-lerobot-dataset" \ --action_horizon 10 \ --encoded_dims "0:6" \ --vocab_size 1024 \ --scale 10.0 \ --normalization_mode QUANTILES \ --output_dir "./my_fast_tokenizer" \ --push_to_hub true \ --hub_repo_id "username/my-action-tokenizer" ``` ### Parâmetros Principais do Tokenizer | Parâmetro | Descrição | Padrão | | ---------------------- | --------------------------------------------------------------------------------- | ------------ | | `--repo_id` | ID do repositório do dataset LeRobot | Obrigatório | | `--action_horizon` | Número de ações futuras em cada bloco | `10` | | `--encoded_dims` | Intervalos de dimensões separados por vírgulas para codificar (por exemplo, `"0:6,7:23"`) | `"0:6,7:23"` | | `--vocab_size` | Tamanho do vocabulário BPE | `1024` | | `--scale` | Fator de escala DCT para quantização | `10.0` | | `--normalization_mode` | Modo de normalização (`MEAN_STD`, `MIN_MAX`, `QUANTILES`, `QUANTILE10`, `IDENTITY`) | `QUANTILES` | | `--sample_fraction` | Fração de blocos a amostrar por episódio | `0.1` | ## Uso Para usar π₀-FAST no LeRobot, especifique o tipo de política como: ```python policy.type=pi0_fast ``` ## Treinamento Para treinar o π₀-FAST, você pode usar o script de treinamento do LeRobot: ```bash lerobot-train \ --dataset.repo_id=your_dataset \ --policy.type=pi0_fast \ --output_dir=./outputs/pi0fast_training \ --job_name=pi0fast_training \ --policy.pretrained_path=lerobot/pi0fast-base \ --policy.dtype=bfloat16 \ --policy.gradient_checkpointing=true \ --policy.chunk_size=10 \ --policy.n_action_steps=10 \ --policy.max_action_tokens=256 \ --steps=100000 \ --batch_size=4 \ --policy.device=cuda ``` ### Parâmetros Principais de Treinamento | Parâmetro | Descrição | Padrão | | -------------------------------------- | -------------------------------------------------- | ------------------------------- | | `--policy.gradient_checkpointing=true` | Reduz significativamente o uso de memória durante o treinamento | `false` | | `--policy.dtype=bfloat16` | Use treinamento com precisão mista para eficiência | `float32` | | `--policy.chunk_size` | Número de etapas de ação a prever (horizonte de ação) | `50` | | `--policy.n_action_steps` | Número de etapas de ação a executar | `50` | | `--policy.max_action_tokens` | Número máximo de tokens FAST por bloco de ações | `256` | | `--policy.action_tokenizer_name` | Tokenizador FAST a ser usado | `lerobot/fast-action-tokenizer` | | `--policy.compile_model=true` | Ative o torch.compile para um treinamento mais rápido | `false` | | `--policy.optimizer_fused=true` | Use AdamW fundido; ignorado ao retomar | `None` | ## Inferência ### KV-Caching para Inferência Rápida π₀-FAST suporta **cache de KV**, uma otimização amplamente utilizada na inferência de LLMs. Isso faz o cache dos pares chave-valor do mecanismo de atenção, evitando cálculos redundantes durante a decodificação autoregressiva. ```python # KV-caching is enabled by default policy.use_kv_cache=true ``` ### Exemplo de Inferência ```python from lerobot.policies.pi0_fast import PI0FastPolicy, PI0FastConfig # Load the policy policy = PI0FastPolicy.from_pretrained("your-model-path") # During inference actions = policy.predict_action_chunk(batch) ``` ## Arquitetura do Modelo π₀-FAST usa uma arquitetura baseada em PaliGemma: - **Vision Encoder**: torre de visão SigLIP para compreensão de imagens - **Modelo de linguagem**: Gemma 2B para processar instruções de linguagem e prever tokens de ação O modelo recebe imagens, instruções de texto e o estado do robô como entrada e produz tokens FAST discretos que são decodificados de volta para ações contínuas. ## Opções de Configuração | Parâmetro | Descrição | Padrão | | -------------------- | ----------------------------------------------- | ---------- | | `paligemma_variant` | Variante do backbone do VLM (`gemma_300m`, `gemma_2b`) | `gemma_2b` | | `max_state_dim` | Dimensão máxima do vetor de estado (com preenchimento) | `32` | | `max_action_dim` | Dimensão máxima do vetor de ação (com preenchimento) | `32` | | `temperature` | Temperatura de amostragem (0.0 para guloso) | `0.0` | | `max_decoding_steps` | Passos máximos de decodificação | `256` | | `use_kv_cache` | Ative o cache de KV para uma inferência mais rápida | `true` | ## Comparação com π₀ | Recurso | π₀ | π₀-FAST | | --------------------- | ------------------------- | ---------------------------- | | Representação de Ação | Flow Matching (Difusão) | Tokens Autoregressivos (FAST) | | Velocidade de Treinamento | 1x | **5x mais rápido** | | Destreza | Alto | Alto | | Método de Inferência | Desruidagem iterativa | Decodificação Autoregressiva | | KV-Caching | N/A | Suportado | ## Reproduzindo os resultados do π₀Fast Reproduzimos os resultados do π₀Fast no benchmark LIBERO usando a implementação do LeRobot. Utilizamos o modelo base LeRobot PiFast [lerobot/pi0fast-base](https://huggingface.co/lerobot/pi0fast-base) e realizamos o finetuning por mais 40k passos em bfloat16, com tamanho de lote de 256 em 8 GPUs H100, usando o [conjunto de dados LIBERO do HuggingFace](https://huggingface.co/datasets/HuggingFaceVLA/libero). O modelo ajustado pode ser encontrado aqui: - **π₀Fast LIBERO**: [lerobot/pi0fast-libero](https://huggingface.co/lerobot/pi0fast-libero) Com o seguinte comando de treinamento: ```bash lerobot-train \ --dataset.repo_id=lerobot/libero \ --output_dir=outputs/libero_pi0fast \ --job_name=libero_pi0fast \ --policy.path=lerobot/pi0fast-base \ --policy.dtype=bfloat16 \ --steps=100000 \ --save_freq=20000 \ --batch_size=4 \ --policy.device=cuda \ --policy.scheduler_warmup_steps=4000 \ --policy.scheduler_decay_steps=100000 \ --policy.scheduler_decay_lr=1e-5 \ --policy.gradient_checkpointing=true \ --policy.chunk_size=10 \ --policy.n_action_steps=10 \ --policy.max_action_tokens=256 \ --policy.empty_cameras=1 ``` Em seguida, avaliamos o modelo finetuned usando a implementação LeRobot LIBERO, executando o seguinte comando: ```bash tasks="libero_object,libero_spatial,libero_goal,libero_10" lerobot-eval \ --policy.path=lerobot/pi0fast-libero \ --policy.max_action_tokens=256 \ --env.type=libero \ --policy.gradient_checkpointing=false \ --env.task=${tasks} \ --eval.batch_size=1 \ --eval.n_episodes=1 \ --rename_map='{"observation.images.image":"observation.images.base_0_rgb","observation.images.image2":"observation.images.left_wrist_0_rgb"}' ``` **Observação:** Definimos `n_action_steps=10`, semelhante à implementação original do OpenPI. ### Resultados Obtemos os seguintes resultados no benchmark LIBERO: | Model | LIBERO Spatial | Objeto LIBERO | Objetivo do LIBERO | LIBERO 10 | Média | | ----------- | -------------- | ------------- | ----------- | --------- | -------- | | **π₀-fast** | 70.0 | 100.0 | 100.0 | 60.0 | **82.5** | A pasta de saída completa da avaliação, incluindo os vídeos, está disponível [aqui](https://drive.google.com/drive/folders/1HXpwPTRm4hx6g1sF2P7OOqGG0TwPU7LQ?usp=sharing) ## Licença Este modelo segue a **Apache 2.0 License**, em conformidade com o repositório original [OpenPI](https://github.com/Physical-Intelligence/openpi). ## Referências - [FAST: Tokenização eficiente de ações de robôs](https://www.physicalintelligence.company/research/fast) - Blog da Physical Intelligence - [Repositório OpenPI](https://github.com/Physical-Intelligence/openpi) - Implementação original - [Tokenizer FAST no Hugging Face](https://huggingface.co/physical-intelligence/fast) - Tokenizer pré-treinado