Тонкая настройка модели 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
Основные компоненты
- Кодировщик изображений: Обрабатывает входные изображения с нескольких ракурсов
- Кодировщик состояний: Обрабатывает информацию о состоянии робота
- Декодер Transformer: Генерирует последовательности действий
- Головка действий: Выводит финальные предсказания действий
Ключевые параметры
- 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")
Лучшие практики
Рекомендации по сбору данных
- Многоракурсные данные: Используйте несколько камер для получения богатой визуальной информации
- Высококачественные демонстрации: Обеспечьте согласованность и точность демонстрационных данных
- Разнообразие задач: Включите различные начальные состояния и конфигурации целей
- Случаи неудач: Соответствующим образом включите случаи неудач для повышения робастности
Рекомендации по оптимизации обучения
- Размер блока действий: Настройте chunk_size в зависимости от сложности задачи
- Планирование скорости обучения: Используйте косинусное затухание или поэтапное снижение
- Регуляризация: Соответствующим образом используйте затухание весов и dropout
- Аугментация данных: Примените соответствующую аугментацию к изображениям
Рекомендации по оптимизации развертывания
- Сжатие модели: Используйте методы квантования и обрезки для уменьшения размера модели
- Ускорение вывода: Используйте TensorRT или ONNX для оптимизации вывода
- Управление памятью: Правильно управляйте очередями действий и кэшами наблюдений
- Гарантия реального времени: Убедитесь, что частота вывода соответствует требованиям управления
Часто задаваемые вопросы (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: Добавлены сжатие модели и оптимизация развертывания