Тонкая настройка модели ACT (Action Chunking Transformer)

Обзор

ACT (Action Chunking Transformer) - это сквозная модель имитационного обучения, специально разработанная для задач точных манипуляций. Модель преодолевает проблему накопления ошибок в традиционном имитационном обучении путем предсказания блоков действий (action chunks), достигая высоких показателей успеха в манипуляциях роботов на недорогом оборудовании.

Основные особенности

• Предсказание блоков действий: Предсказывает несколько последовательных действий одновременно, уменьшая накопление ошибок
• Архитектура Transformer: Использует механизм внимания для обработки последовательных данных
• Сквозное обучение: Напрямую предсказывает действия из необработанных наблюдений
• Высокая частота успеха: Отличные результаты в задачах точных манипуляций
• Дружелюбность к оборудованию: Может работать на потребительском оборудовании

Предварительные требования

Системные требования

• Операционная система: Linux (рекомендуется Ubuntu 20.04+) или macOS
• Версия Python: 3.8+
• GPU: NVIDIA GPU (рекомендуется RTX 3070 или выше), минимум 6GB видеопамяти
• Память: Минимум 16GB RAM
• Дисковое пространство: Минимум 30GB свободного места

Подготовка среды

1. Установка LeRobot

# Клонировать репозиторий LeRobot
git clone https://github.com/huggingface/lerobot.git
cd lerobot

# Создать виртуальную среду
conda create -n lerobot python=3.10
conda activate lerobot

# Установить зависимости
pip install -e .

2. Установка специфичных зависимостей ACT

# Установить дополнительные пакеты
pip install einops
pip install timm
pip install wandb

# Войти в Weights & Biases (опционально)
wandb login

Архитектура модели ACT

Основные компоненты

1. Кодировщик изображений: Обрабатывает входные изображения с нескольких ракурсов
2. Кодировщик состояний: Обрабатывает информацию о состоянии робота
3. Декодер Transformer: Генерирует последовательности действий
4. Головка действий: Выводит финальные предсказания действий

Ключевые параметры

• Chunk Size: Количество предсказываемых действий за раз (обычно 50-100)
• Context Length: Длина исторических наблюдений
• Hidden Dimension: Скрытая размерность Transformer
• Number of Heads: Количество голов внимания
• Number of Layers: Количество слоев Transformer

Подготовка данных

Данные формата LeRobot

ACT требует использования наборов данных формата LeRobot, содержащих следующую структуру:

your_dataset/
├── data/
│   ├── chunk-001/
│   │   ├── observation.images.cam_high.png
│   │   ├── observation.images.cam_low.png
│   │   ├── observation.images.cam_left_wrist.png
│   │   ├── observation.images.cam_right_wrist.png
│   │   ├── observation.state.npy
│   │   ├── action.npy
│   │   └── ...
│   └── chunk-002/
│       └── ...
├── meta.json
├── stats.safetensors
└── videos/
    ├── episode_000000.mp4
    └── ...

Требования к качеству данных

• Минимум 50 эпизодов для базового обучения
• Рекомендуется 200+ эпизодов для оптимальных результатов
• Каждый эпизод должен содержать полное выполнение задачи
• Изображения с нескольких ракурсов (минимум 2 камеры)
• Высококачественные аннотации действий

Тонкая настройка обучения

Важное ограничение параметров

Параметр n_action_steps модели ACT должен быть ≤ chunk_size. Рекомендуется установить оба параметра на одно и то же значение (например, оба на 100).

• chunk_size: Длина последовательности действий, предсказываемой моделью за раз
• n_action_steps: Количество фактически выполняемых шагов действий

Базовая команда обучения

# Установить переменные среды
export HF_USER="your-huggingface-username"
export CUDA_VISIBLE_DEVICES=0

# Запустить обучение ACT
lerobot-train \
  --policy.type act \
  --dataset.repo_id ${HF_USER}/your_dataset \
  --batch_size 8 \
  --steps 50000 \
  --output_dir outputs/train/act_finetuned \
  --job_name act_finetuning \
  --policy.device cuda \
  --policy.chunk_size 100 \
  --policy.n_action_steps 100 \
  --policy.n_obs_steps 1 \
  --policy.optimizer_lr 1e-5 \
  --policy.optimizer_weight_decay 1e-4 \
  --policy.push_to_hub false \
  --save_checkpoint true \
  --save_freq 10000 \
  --wandb.enable true

Расширенная конфигурация обучения

Конфигурация с несколькими камерами

# Обучение ACT с настройкой нескольких камер
lerobot-train \
  --policy.type act \
  --dataset.repo_id ${HF_USER}/your_dataset \
  --batch_size 4 \
  --steps 100000 \
  --output_dir outputs/train/act_multicam \
  --job_name act_multicam_training \
  --policy.device cuda \
  --policy.chunk_size 100 \
  --policy.n_action_steps 100 \
  --policy.n_obs_steps 2 \
  --policy.vision_backbone resnet18 \
  --policy.dim_model 512 \
  --policy.dim_feedforward 3200 \
  --policy.n_encoder_layers 4 \
  --policy.n_decoder_layers 1 \
  --policy.n_heads 8 \
  --policy.optimizer_lr 1e-5 \
  --policy.optimizer_weight_decay 1e-4 \
  --policy.push_to_hub false \
  --save_checkpoint true \
  --wandb.enable true

Конфигурация оптимизации памяти

# Для GPU с меньшей видеопамятью
lerobot-train \
  --policy.type act \
  --dataset.repo_id io-ai-data/lerobot_data \
  --batch_size 2 \
  --steps 75000 \
  --output_dir outputs/train/act_memory_opt \
  --job_name act_memory_optimized \
  --policy.device cuda \
  --policy.chunk_size 100 \
  --policy.n_action_steps 100 \
  --policy.n_obs_steps 1 \
  --policy.vision_backbone resnet18 \
  --policy.dim_model 256 \
  --policy.optimizer_lr 1e-5 \
  --policy.use_amp true \
  --num_workers 2 \
  --policy.push_to_hub false \
  --save_checkpoint true \
  --wandb.enable true

Подробное описание параметров

Основные параметры

Параметр	Значение	Рекомендуемое значение	Описание
--policy.type	Тип политики	act	Тип модели ACT
--policy.pretrained_path	Путь к предобученной модели	lerobot/act	Официальная модель ACT LeRobot (опционально)
--dataset.repo_id	ID репозитория набора данных	${HF_USER}/dataset	Ваш набор данных HuggingFace
--batch_size	Размер пакета	8	Настроить в соответствии с видеопамятью, RTX 3070 рекомендуется 4-8
--steps	Шаги обучения	50000	Точные задачи рекомендуется 50000-100000 шагов
--output_dir	Выходной каталог	outputs/train/act_finetuned	Путь сохранения модели
--job_name	Имя задачи	act_finetuning	Для логирования и отслеживания экспериментов (опционально)

Специфичные для ACT параметры

Параметр	Значение	Рекомендуемое значение	Описание
--policy.chunk_size	Размер блока действий	100	Количество предсказываемых действий каждый раз
--policy.n_action_steps	Шаги выполнения действий	100	Количество фактически выполняемых действий
--policy.n_obs_steps	Шаги наблюдения	1	Количество исторических наблюдений
--policy.vision_backbone	Визуальный остов	resnet18	Сеть извлечения признаков изображений
--policy.dim_model	Размерность модели	512	Основная размерность Transformer
--policy.dim_feedforward	Размерность прямого распространения	3200	Размерность слоя прямого распространения Transformer
--policy.n_encoder_layers	Слои кодировщика	4	Количество слоев кодировщика Transformer
--policy.n_decoder_layers	Слои декодера	1	Количество слоев декодера Transformer
--policy.n_heads	Головы внимания	8	Количество голов в многоголовом внимании
--policy.use_vae	Использовать VAE	true	Вариационная оптимизация целевой функции

Параметры обучения

Параметр	Значение	Рекомендуемое значение	Описание
--policy.optimizer_lr	Скорость обучения	1e-5	ACT рекомендует меньшую скорость обучения
--policy.optimizer_weight_decay	Затухание весов	0.0	Параметр регуляризации
--policy.optimizer_lr_backbone	Скорость обучения остова	1e-5	Скорость обучения визуального кодировщика
--policy.use_amp	Смешанная точность	true	Экономит видеопамять
--num_workers	Потоки загрузки данных	4	Настроить в соответствии с количеством ядер CPU
--policy.push_to_hub	Отправить в Hub	false	Загружать ли модель в HuggingFace (требуется repo_id)
--save_checkpoint	Сохранить контрольные точки	true	Сохранять ли контрольные точки обучения
--save_freq	Частота сохранения	10000	Интервал сохранения контрольных точек

Мониторинг и отладка обучения

Интеграция с Weights & Biases

# Подробная конфигурация W&B
lerobot-train \
  --policy.type act \
  --dataset.repo_id your-name/your-dataset \
  --batch_size 8 \
  --steps 50000 \
  --policy.push_to_hub false \
  --wandb.enable true \
  --wandb.project act_experiments \
  --wandb.notes "ACT training with 4 cameras" \
  # ... другие параметры

Мониторинг ключевых метрик

Метрики для отслеживания во время обучения:

• Total Loss: Общая потеря, должна стабильно уменьшаться
• Action Loss: Потеря предсказания действий (L1/L2 потеря)
• Learning Rate: Кривая изменения скорости обучения
• Gradient Norm: Норма градиента, мониторинг взрыва градиента
• GPU Memory: Использование видеопамяти
• Training Speed: Количество обработанных образцов в секунду

Анализ логов обучения

# log_analysis.py
import wandb
import matplotlib.pyplot as plt

def analyze_training_logs(project_name, run_name):
    api = wandb.Api()
    run = api.run(f"{project_name}/{run_name}")
    
    # Получить метрики обучения
    history = run.history()
    
    # Построить кривые потерь
    plt.figure(figsize=(12, 4))
    
    plt.subplot(1, 3, 1)
    plt.plot(history['step'], history['train/total_loss'])
    plt.title('Total Loss')
    plt.xlabel('Step')
    plt.ylabel('Loss')
    
    plt.subplot(1, 3, 2)
    plt.plot(history['step'], history['train/action_loss'])
    plt.title('Action Loss')
    plt.xlabel('Step')
    plt.ylabel('Loss')
    
    plt.subplot(1, 3, 3)
    plt.plot(history['step'], history['train/learning_rate'])
    plt.title('Learning Rate')
    plt.xlabel('Step')
    plt.ylabel('LR')
    
    plt.tight_layout()
    plt.savefig('training_analysis.png')
    plt.show()

if __name__ == "__main__":
    analyze_training_logs("act_experiments", "act_v1_multicam")

Оценка модели

Офлайн оценка

# offline_evaluation.py
import torch
import numpy as np
from lerobot.policies.act.modeling_act import ACTPolicy
from lerobot.datasets.lerobot_dataset import LeRobotDataset

def evaluate_act_model(model_path, dataset_path):
    # Загрузить модель
    policy = ACTPolicy.from_pretrained(model_path, device="cuda")
    policy.eval()
    
    # Загрузить тестовый набор данных
    dataset = LeRobotDataset(dataset_path, split="test")
    
    total_l1_loss = 0
    total_l2_loss = 0
    num_samples = 0
    
    with torch.no_grad():
        for batch in dataset:
            # Предсказание модели
            prediction = policy(batch)
            
            # Вычислить потерю
            target_actions = batch['action']
            predicted_actions = prediction['action']
            
            l1_loss = torch.mean(torch.abs(predicted_actions - target_actions))
            l2_loss = torch.mean((predicted_actions - target_actions) ** 2)
            
            total_l1_loss += l1_loss.item()
            total_l2_loss += l2_loss.item()
            num_samples += 1
    
    avg_l1_loss = total_l1_loss / num_samples
    avg_l2_loss = total_l2_loss / num_samples
    
    print(f"Average L1 Loss: {avg_l1_loss:.4f}")
    print(f"Average L2 Loss: {avg_l2_loss:.4f}")
    
    return avg_l1_loss, avg_l2_loss

if __name__ == "__main__":
    model_path = "outputs/train/act_finetuned/checkpoints/last"
    dataset_path = "path/to/your/test/dataset"
    evaluate_act_model(model_path, dataset_path)

Онлайн оценка (среда робота)

# robot_evaluation.py
import torch
import numpy as np
from lerobot.policies.act.modeling_act import ACTPolicy

class ACTRobotController:
    def __init__(self, model_path, camera_names):
        self.policy = ACTPolicy.from_pretrained(model_path, device="cuda")
        self.policy.eval()
        self.camera_names = camera_names
        self.action_queue = []
        
    def get_action(self, observations):
        # Если очередь действий пуста, предсказать новый блок действий
        if len(self.action_queue) == 0:
            with torch.no_grad():
                # Построить вход
                batch = self.prepare_observation(observations)
                
                # Предсказать блок действий
                prediction = self.policy(batch)
                actions = prediction['action'].cpu().numpy()[0]  # [chunk_size, action_dim]
                
                # Добавить действия в очередь
                self.action_queue = list(actions)
        
        # Вернуть следующее действие из очереди
        return self.action_queue.pop(0)
    
    def prepare_observation(self, observations):
        batch = {}
        
        # Обработать наблюдения изображений
        for cam_name in self.camera_names:
            image_key = f"observation.images.{cam_name}"
            if image_key in observations:
                image = observations[image_key]
                # Предобработать изображение (нормализация, изменение размера и т.д.)
                image_tensor = self.preprocess_image(image)
                batch[image_key] = image_tensor.unsqueeze(0)
        
        # Обработать наблюдения состояний
        if "observation.state" in observations:
            state = torch.tensor(observations["observation.state"], dtype=torch.float32)
            batch["observation.state"] = state.unsqueeze(0)
        
        return batch
    
    def preprocess_image(self, image):
        # Логика предобработки изображения
        # Должна соответствовать предобработке, используемой во время обучения
        image_tensor = torch.tensor(image).permute(2, 0, 1).float() / 255.0
        return image_tensor

# Пример использования
if __name__ == "__main__":
    controller = ACTRobotController(
        model_path="outputs/train/act_finetuned/checkpoints/last",
        camera_names=["cam_high", "cam_low", "cam_left_wrist", "cam_right_wrist"]
    )
    
    # Симуляция цикла управления роботом
    for step in range(100):
        # Получить текущее наблюдение (должно быть получено от реального робота)
        observations = {
            "observation.images.cam_high": np.random.randint(0, 255, (480, 640, 3)),
            "observation.images.cam_low": np.random.randint(0, 255, (480, 640, 3)),
            "observation.state": np.random.randn(7)
        }
        
        # Получить действие
        action = controller.get_action(observations)
        
        # Выполнить действие (отправить роботу)
        print(f"Step {step}: Action = {action}")
        
        # Это должно отправить действие реальному роботу
        # robot.execute_action(action)

Развертывание и оптимизация

Квантование модели

# quantization.py
import torch
from lerobot.policies.act.modeling_act import ACTPolicy

def quantize_act_model(model_path, output_path):
    # Загрузить модель
    policy = ACTPolicy.from_pretrained(model_path, device="cpu")
    policy.eval()
    
    # Динамическое квантование
    quantized_policy = torch.quantization.quantize_dynamic(
        policy, 
        {torch.nn.Linear}, 
        dtype=torch.qint8
    )
    
    # Сохранить квантованную модель
    torch.save(quantized_policy.state_dict(), output_path)
    print(f"Quantized model saved to {output_path}")
    
    return quantized_policy

if __name__ == "__main__":
    quantize_act_model(
        "outputs/train/act_finetuned/checkpoints/last",
        "outputs/act_quantized.pth"
    )

Оптимизация вывода

# optimized_inference.py
import torch
import torch.jit
from lerobot.policies.act.modeling_act import ACTPolicy

class OptimizedACTInference:
    def __init__(self, model_path, use_jit=True):
        self.policy = ACTPolicy.from_pretrained(model_path, device="cuda")
        self.policy.eval()
        
        if use_jit:
            # Оптимизировать с помощью TorchScript
            self.policy = torch.jit.script(self.policy)
        
        # Прогреть модель
        self.warmup()
    
    def warmup(self):
        # Прогреть модель с фиктивными данными
        dummy_batch = {
            "observation.images.cam_high": torch.randn(1, 3, 224, 224, device="cuda"),
            "observation.images.cam_low": torch.randn(1, 3, 224, 224, device="cuda"),
            "observation.state": torch.randn(1, 7, device="cuda")
        }
        
        with torch.no_grad():
            for _ in range(10):
                _ = self.policy(dummy_batch)
    
    @torch.no_grad()
    def predict(self, observations):
        # Быстрый вывод
        prediction = self.policy(observations)
        return prediction['action'].cpu().numpy()

if __name__ == "__main__":
    inference = OptimizedACTInference(
        "outputs/train/act_finetuned/checkpoints/last"
    )
    
    # Тестировать скорость вывода
    import time
    
    observations = {
        "observation.images.cam_high": torch.randn(1, 3, 224, 224, device="cuda"),
        "observation.images.cam_low": torch.randn(1, 3, 224, 224, device="cuda"),
        "observation.state": torch.randn(1, 7, device="cuda")
    }
    
    start_time = time.time()
    for _ in range(100):
        action = inference.predict(observations)
    end_time = time.time()
    
    avg_inference_time = (end_time - start_time) / 100
    print(f"Average inference time: {avg_inference_time:.4f} seconds")
    print(f"Inference frequency: {1/avg_inference_time:.2f} Hz")

Лучшие практики

Рекомендации по сбору данных

1. Многоракурсные данные: Используйте несколько камер для получения богатой визуальной информации
2. Высококачественные демонстрации: Обеспечьте согласованность и точность демонстрационных данных
3. Разнообразие задач: Включите различные начальные состояния и конфигурации целей
4. Случаи неудач: Соответствующим образом включите случаи неудач для повышения робастности

Рекомендации по оптимизации обучения

1. Размер блока действий: Настройте chunk_size в зависимости от сложности задачи
2. Планирование скорости обучения: Используйте косинусное затухание или поэтапное снижение
3. Регуляризация: Соответствующим образом используйте затухание весов и dropout
4. Аугментация данных: Примените соответствующую аугментацию к изображениям

Рекомендации по оптимизации развертывания

1. Сжатие модели: Используйте методы квантования и обрезки для уменьшения размера модели
2. Ускорение вывода: Используйте TensorRT или ONNX для оптимизации вывода
3. Управление памятью: Правильно управляйте очередями действий и кэшами наблюдений
4. Гарантия реального времени: Убедитесь, что частота вывода соответствует требованиям управления

Часто задаваемые вопросы (FAQ)

Q: Какие преимущества имеет ACT по сравнению с другими методами имитационного обучения?

A: Основные преимущества ACT включают:

• Уменьшение накопления ошибок: Уменьшает накопление ошибок путем предсказания блоков действий
• Повышение частоты успеха: Отличные результаты в задачах точных манипуляций
• Сквозное обучение: Нет необходимости в разработке признаков вручную
• Многомодальное слияние: Эффективно объединяет визуальную информацию и информацию о состоянии

Q: Как выбрать подходящий chunk_size?

A: Выбор chunk_size зависит от характеристик задачи:

• Быстрые задачи: chunk_size = 10-30
• Средние задачи: chunk_size = 50-100
• Медленные задачи: chunk_size = 100-200
• Обычно рекомендуется начать с 50

Q: Сколько времени занимает обучение?

A: Время обучения зависит от нескольких факторов:

• Размер набора данных: 100 эпизодов занимают примерно 4-8 часов (RTX 3070)
• Сложность модели: Более крупные модели требуют больше времени
• Конфигурация оборудования: Лучшие GPU могут значительно сократить время обучения
• Требования к сходимости: Обычно требуется 50000-100000 шагов

Q: Как обрабатывать данные с нескольких камер?

A: Рекомендации по обработке нескольких камер:

• Выбор камер: Выбирайте дополняющие точки обзора
• Слияние признаков: Объединяйте на уровне признаков
• Механизм внимания: Позвольте модели научиться фокусироваться на важных точках обзора
• Вычислительные ресурсы: Обратите внимание, что несколько камер увеличивают вычислительную нагрузку

Q: Как улучшить способность модели к обобщению?

A: Методы улучшения способности к обобщению:

• Разнообразие данных: Собирайте данные в различных условиях
• Аугментация данных: Используйте методы аугментации изображений и действий
• Регуляризация: Соответствующее затухание весов и dropout
• Рандомизация домена: Используйте методы рандомизации домена в симуляции
• Многозадачное обучение: Совместное обучение на нескольких связанных задачах

Связанные ресурсы

• Оригинальная статья ACT
• Реализация ACT LeRobot
• Официальный код ACT
• Учебник по обучению роботов
• Документация LeRobot

Журнал изменений

• 2024-01: Релиз начальной версии
• 2024-02: Добавлена поддержка нескольких камер
• 2024-03: Оптимизирована эффективность обучения и скорость вывода
• 2024-04: Добавлены сжатие модели и оптимизация развертывания