Cosmos3

Cosmos3 — это модель действий мира для управления роботами, построенная на базе Cosmos 3, семейства омнимодальных моделей мира от NVIDIA. На основе данных с камер и языковой инструкции политика совместно предсказывает будущие кадры видео и следующий блок действий робота. Реализация в LeRobot адаптирована из нативной политики действий cosmos-framework и работает с опубликованными моделями Cosmos3 Nano и Edge, преобразованными в формат LeRobot.

• 📄 Технический отчёт Cosmos 3 (arXiv:2606.02800)
• 💻 cosmos-framework и Cosmos cookbook
• 🤗 Коллекция моделей Cosmos 3

Обзор модели

Cosmos 3 представляет собой Mixture-of-Transformers (MoT). Каждый слой декодера имеет два пути со своими собственными нормализациями слоев, проекциями внимания и MLP, а эти два пути встречаются только в общем self-attention:

• Путь понимания (разумитель) читает токены текста из запроса и, при необходимости, токены изображений ViT с использованием каузального внимания.
• Путь генерации (генератор) считывает непрерывные токены диффузионного подпоследовательности: латенты VAE Wan2.2 для видео и токены действий. Он обращается двунаправленно к обоим путям и обучается с помощью flow matching.

Архитектура Mixture-of-Transformers (MoT) в Cosmos 3 (рисунок 5 из технического отчёта). Слева: авторегрессионная (AR) подпоследовательность проходит через reasoner, а диффузионная (DM) подпоследовательность — через generator, после чего они объединяются в общем мультимодальном attention. Справа: маска attention, каузальная для AR и полная для диффузии.

В соответствии с политикой, Cosmos3 работает в режиме модели действий в мире для нативных рецептов действий:

• Входные данные: кадры с камер собираются в единое видео-полотно (один кадр — как есть, два — рядом, три — первый сверху, два других под ним). Запрос содержит задачу, частоту кадров, разрешение полотна, описание его компоновки и количество пустых кадров в блоке.
• Обучение: политика кодирует клип текущего кадра и chunk_size будущих кадров с помощью VAE, добавляет шум к будущим латентам и к чанку действий и обучается их денуайзу. Потери представляют собой взвешенную сумму видео-потерь и потерь действий.
• Вывод: кадр условия чистый, будущее видео и действия образуются совместно с помощью решателя UniPC, а политика возвращает блок действий. Предсказанное видео можно сохранить во время оценки (см. Оценка).
• По умолчанию обучаются только генерационный путь, слои вокруг него и модули действий (train_gen_stream_only=true, freeze_vision_encoder=true), как в нативных рецептах пост-обучения.

LeRobot предоставляет два выпущенных размера в виде двух типов политик:

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

1. Установите LeRobot, следуя нашему Руководству по установке.

2. Установите зависимости Cosmos3:

   Скопировано

   pip install -e ".[cosmos3]"

   Если вы установили LeRobot из PyPI:

   Скопировано

   pip install 'lerobot[cosmos3]'

3. Добавьте дополнительные компоненты вашего рабочего процесса: training для lerobot-train, libero для обучения или оценки на LIBERO и peft для LoRA. Например:

   Скопировано

   pip install -e ".[cosmos3,training,libero]"

Cosmos3 по умолчанию использует бэкенд PyTorch для масштабированного внимания на основе скалярного произведения (sdpa). Если в вашей среде установлена совместимая версия flash_attn, вы можете запросить --policy.attn_implementation=flash_attention_2. Не используйте его вместе с --policy.compile_model=true: скомпилированные слои декодера будут перекомпилироваться для каждого слоя с flash attention, что приведёт к ошибке перекомпиляции.

Чекпоинты

• Базовые контрольные точки содержат выпущенные веса в формате LeRobot. Их модули действий (action2llm, llm2action, action_modality_embed) ещё не обучены для робота, поэтому начните дообучение с --policy.load_action_modules=false (см. Дообучение на LIBERO).
• Файл config.json базовых контрольных точек содержит нативный рецепт пост-обучения DROID, а значения по умолчанию для классов типов политик соответствуют нативному рецепту LIBERO.
• Чекпоинты LIBERO содержат веса EMA, полученные в ходе их обучения.
• Веса хранятся в формате bfloat16. config.json намеренно задаёт dtype: float32: обучение с смешанной точностью из этих контрольных точек сохраняет мастер-веса в float32, как и при нативном обучении. Для вывода и оценки передавайте --policy.dtype=bfloat16.

Существует два способа начать с контрольной точки:

• --policy.path=<checkpoint> загружает сохранённую конфигурацию, веса и процессоры, а затем применяет параметры командной строки поверх них.
• --policy.type=cosmos3_nano --policy.pretrained_path=<checkpoint> (или cosmos3_edge) загружает только веса и процессоры, а конфигурация начинается со значений по умолчанию класса, рецепта LIBERO.

Допобучение на LIBERO

Значения по умолчанию для класса соответствуют рецепту LIBERO из технического отчёта: блоки из 16 действий, воплощение domain_id=5, отсутствие действия состояния, квантильная нормализация действий, UniPC с 30 шагами и без классификаторного свободного руководства при выводе, а также скорость обучения 5e-5 с 500 шагами разгона и линейным затуханием до нуля на шаге 16000. Таким образом, при запуске из базовой контрольной точки с --policy.type достаточно указать --policy.load_action_modules=false.

Рецепт обучается на данных LIBERO, преобразованных в формат Cosmos3:

• lerobot/LIBERO-Cosmos3: четыре набора (Spatial, Object, Goal, 10), 1693 эпизода.
• lerobot/LIBERO_10-Cosmos3: только LIBERO-10, 379 эпизодов.

Обе версии происходят из nvidia/LIBERO_LeRobot_v3, данных нативного рецепта. Действия имеют размерность 10D [delta position (3), rot6d (6), gripper] вместо 7D-действий axis angle в LIBERO, две камеры observation.images.image (вид от третьего лица) и observation.images.image2 (камера на запястье) имеют разрешение 256x256 при 20 FPS, а статистика действий соответствует нативному рецепту. Во время оценки среда LIBERO преобразует действия обратно (см. Evaluation).

Команда обучения

Нативный рецепт LIBERO обучает модель с глобальным размером батча 2048 образцов в течение 2000 итераций на LIBERO-10 (лучший чекпоинт находится около итерации 1500) и в течение 5000 итераций на четырёх наборах (лучший около 4500). Команда ниже воспроизводит этот процесс на одной машине с 8 GPU: FSDP2 на 8 GPU, 32 образца на GPU и 8 шагов накопления градиентов, что даёт 32 x 8 x 8 = 2048 образцов на обновление оптимизатора. Каждое нативное количество итераций умножается на 8 шагов накопления: 2000 итераций становятся --steps=16000, чекпоинт каждые 500 итераций — --save_freq=4000, а warmup 500 и конец затухания 16000 становятся 4000 и 128000 соответственно.

accelerate launch --num_processes=8 $(which lerobot-train) \
  --policy.type=cosmos3_nano \
  --policy.pretrained_path=lerobot/Cosmos3-Nano \
  --policy.load_action_modules=false \
  --policy.gradient_checkpointing=true \
  --policy.repo_id=${HF_USER}/Cosmos3-Nano-Policy-LIBERO_10 \
  --dataset.repo_id=lerobot/LIBERO_10-Cosmos3 \
  --parallelism.dp_shard=8 \
  --accelerator.fsdp.mixed_precision_policy.param_dtype=bfloat16 \
  --accelerator.fsdp.mixed_precision_policy.reduce_dtype=bfloat16 \
  --accelerator.fsdp.mixed_precision_policy.cast_forward_inputs=false \
  --accelerator.gradient_accumulation.steps=8 \
  --accelerator.gradient_accumulation.sync_each_batch=true \
  --tf32=false \
  --ema.type=power \
  --ema.sigma_rel=0.1 \
  --batch_size=32 \
  --steps=16000 \
  --save_freq=4000 \
  --policy.scheduler_warmup_steps=4000 \
  --policy.scheduler_decay_steps=128000 \
  --output_dir=outputs/train/cosmos3_nano_libero_10 \
  --job_name=cosmos3_nano_libero_10 \
  --trackio.enable=true

Для четырёх наборов используйте --dataset.repo_id=lerobot/LIBERO-Cosmos3 и --steps=40000 (5000 итераций). Для Cosmos3 Edge используйте --policy.type=cosmos3_edge --policy.pretrained_path=lerobot/Cosmos3-Edge.

Ключевые параметры обучения

На одном GPU или при использовании DDP замените флаги FSDP2 (--parallelism.dp_shard и --accelerator.fsdp.mixed_precision_policy.*) на --accelerator.mixed_precision=bf16. Например, Cosmos3 Edge на одном GPU, с 32 образцами на шаг и 64 шагами накопления для того же глобального батча 2048:

lerobot-train \
  --policy.type=cosmos3_edge \
  --policy.pretrained_path=lerobot/Cosmos3-Edge \
  --policy.load_action_modules=false \
  --policy.gradient_checkpointing=true \
  --policy.repo_id=${HF_USER}/Cosmos3-Edge-Policy-LIBERO_10 \
  --dataset.repo_id=lerobot/LIBERO_10-Cosmos3 \
  --accelerator.mixed_precision=bf16 \
  --accelerator.gradient_accumulation.steps=64 \
  --tf32=false \
  --ema.type=power \
  --ema.sigma_rel=0.1 \
  --batch_size=32 \
  --steps=128000 \
  --save_freq=32000 \
  --policy.scheduler_warmup_steps=32000 \
  --policy.scheduler_decay_steps=1024000 \
  --output_dir=outputs/train/cosmos3_edge_libero_10

--policy.load_action_modules=false сбрасывается в true после загрузки контрольной точки, поэтому сохранённый запуск снова загружает свои обученные модули действий. В двух случаях модули действий по ошибке остаются в состоянии инициализации:

• Создание политики без --policy.pretrained_path или --policy.path: ничего не загружается, поэтому флаг остаётся false, а последующая оценка или возобновление этого запуска пропускает обученные модули действий.
• PEFT с модулями действий вне --peft.full_training_modules: в этом случае модули действий никогда не обучаются.

Устанавливайте --policy.load_action_modules=false только при дообучении из базовой контрольной точки. При использовании PEFT оставляйте модули действий в --peft.full_training_modules (значение по умолчанию).

Требования к оборудованию

Замеры выполнены на GPU A800 80 ГБ с использованием команд, приведённых на этой странице, и с включённым градиентным чекпоинтингом:

• Cosmos3 Nano требует GPU с 80 ГБ памяти, и для полной дообучения нужно как минимум 4 таких устройства: до того, как FSDP2 разобьёт модель на части, каждый GPU хранит всю модель в float32 (около 66 ГБ).
• Команда LIBERO выше занимает около 45 секунд на одно обновление оптимизатора на 8 GPU A800, поэтому обучение LIBERO-10 занимает около 25 часов.

Допобучение на собственных данных

Cosmos3 получает рецепт обучения из командной строки и набор данных: политика не содержит логики, специфичной для робота. Любой набор данных LeRobot будет работать, если он соответствует приведенным ниже требованиям.

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

• Камеры: от одного до трёх признаков observation.images.* в порядке, указанном в файле info.json датасета. Каждый вид масштабируется до размера --policy.view_size (по умолчанию — размер первой камеры) и объединяется в одно видео-полотно: один вид отображается как есть, два — рядом, три — первый сверху, а два других — рядом под ним. Расположите камеры в соответствии с этим расположением, например [third person, wrist] для LIBERO и [wrist, exterior 1, exterior 2] для DROID.
• Описание вида: --policy.view_description — это предложение в промпте, описывающее расположение элементов на холсте. По умолчанию описываются раскладка LIBERO (значения по умолчанию класса) и раскладка DROID (базовый config.json). Напишите предложение, описывающее вашу собственную раскладку: неверное описание не будет обнаружено и лишь ослабит промпт.
• Представление действий: политика обучается действиям из набора данных в том виде, в котором они заданы, без этапа преобразования. Преобразуйте действия в нужное вам представление перед обучением, как это делает набор данных LIBERO с вращениями rot6d. Если среда ожидает другое представление, преобразуйте действия обратно в процессорах среды (среда LIBERO делает это для Cosmos3).
• Ширина действия: не более --policy.max_action_dim (64) каналов. Выходная ширина определяется набором данных.
• Частота кадров: fps берётся из метаданных набора данных и должна соответствовать реальной частоте управления: она записывается в промпт и задаёт временную ось позиций видео, а также пороги для неактивных кадров.
• Статистика: по умолчанию используется нормализация QUANTILES, для которой требуются статистические данные q01 и q99 действия из файла meta/stats.json (наборы данных, созданные LeRobot, содержат их). Нативный рецепт DROID использует вместо этого IDENTITY.
• Состояние: при --policy.use_state=true текущее состояние размещается перед действиями в виде чистого действия состояния. Тогда observation.state должна иметь ту же ширину и смысл каналов, что и действие. Состояние и действие нормализуются с использованием собственных статистик.
• Язык: task каждого кадра — это инструкция из промпта.
• Embodiment: --policy.domain_id выбирает строку проекций действий, одну из 32. В стандартных рецептах используется значение 5 для LIBERO, 8 для DROID и 30 для RoboCasa. Если модули действий запускаются с начальной инициализацией (--policy.load_action_modules=false), каждая строка начинается в необученном состоянии, и любое значение подходит.
• Chunk: --policy.chunk_size действий на чанк (16 для LIBERO, 32 для DROID) и --policy.n_action_steps действий, выполняемых на чанк.

Поля, оставленные равными None (fps, view_size), а также имена каналов действий берутся из набора данных. Все остальные поля берутся из конфигурации, поэтому задайте их в командной строке или в файле --config_path.

Имена каналов действий и состояний. В промпте указано, сколько кадров в чанке являются простоями (робот не двигается), и Cosmos3IdleFrameProcessorStep подсчитывает их по именам каналов действий в meta/info.json. Имена вида [<prefix>_]<type>_<index> указывают типы каналов: pos, вращение (rot6d, rot9d, axisangle, euler_xyz, quat_xyzw, quat_wxyz), gripper или joint, с префиксом для различения рук (например, left_rot6d_0). Данные LIBERO используют pos_0..2, rot6d_0..5, gripper_0, а раскладка DROID — joint_0..6, gripper_0.

Это именование не является обязательным. Без него политика лишь выводит предупреждение, а подсчёт не учитывает бездействующие кадры, что и так соответствует тому, что видит рецепт LIBERO (в его эпизодах нет бездействующих кадров согласно нативному правилу). Используйте это именование только в том случае, если вам нужен подсчёт бездействующих кадров для нативного рецепта DROID.

Рецепт DROID

Файл config.json базовых контрольных точек содержит нативный рецепт пост-обучения DROID: воплощение domain_id=8, чанки из 32 действий, текущее состояние в качестве действия состояния и учёт кадров простоя на его основе (use_state=true, idle_state=true), без нормализации (IDENTITY), UniPC с 4 шагами и масштабом classifier-free guidance, равным 3, на этапе инференса, а также скорость обучения 8e-5 (нативные 2e-4, умноженные на коэффициент 0.4) без warmup и с линейным затуханием до нуля на шаге 100000. Запуск обучения с этого файла с помощью --policy.path использует данный рецепт.

Нативный рецепт обучается на успешных эпизодах nvidia/Cosmos3-DROID. Набор данных DROID в формате Cosmos3 содержит:

• Три камеры observation.images.wrist_left, observation.images.exterior_1_left и observation.images.exterior_2_left в этом порядке (камера на запястье сверху, два внешних вида под ней), разрешение 360x640 в исходных данных.
• 8D действия по позициям суставов с именами joint_0–joint_6 и gripper_0, а также observation.state с той же структурой.
• Частота кадров 15 FPS.

Нативный рецепт обучает модель с глобальной партией из 8192 образцов в течение 10000 итераций, сохраняя контрольную точку каждые 1000 итераций. На одной машине с 8 GPU, 8 образцами на GPU и 128 шагами накопления получается та же глобальная партия (8 x 8 x 128 = 8192), а количество каждой итерации умножается на 128:

accelerate launch --num_processes=8 $(which lerobot-train) \
  --policy.path=lerobot/Cosmos3-Nano \
  --policy.load_action_modules=false \
  --policy.gradient_checkpointing=true \
  --policy.repo_id=${HF_USER}/Cosmos3-Nano-Policy-DROID \
  --dataset.repo_id=${HF_USER}/DROID-Cosmos3 \
  --parallelism.dp_shard=8 \
  --accelerator.fsdp.mixed_precision_policy.param_dtype=bfloat16 \
  --accelerator.fsdp.mixed_precision_policy.reduce_dtype=bfloat16 \
  --accelerator.fsdp.mixed_precision_policy.cast_forward_inputs=false \
  --accelerator.gradient_accumulation.steps=128 \
  --accelerator.gradient_accumulation.sync_each_batch=true \
  --tf32=false \
  --ema.type=power \
  --ema.sigma_rel=0.1 \
  --batch_size=8 \
  --steps=1280000 \
  --save_freq=128000 \
  --policy.scheduler_decay_steps=12800000 \
  --output_dir=outputs/train/cosmos3_nano_droid \
  --job_name=cosmos3_nano_droid \
  --trackio.enable=true

Нативный рецепт DROID выполнялся на 256 GPU. На одном сервере с 8 GPU A800 одно обновление оптимизатора для этой команды занимает около 33 минут, поэтому для полного рецепта требуется несколько серверов. Запустите ту же команду на каждом сервере с флагами для мультинодового режима accelerate launch (или torchrun), разбейте параметры внутри каждого сервера и продублируйте их между серверами с помощью --parallelism.dp_replicate=<number of machines> --parallelism.dp_shard=8, а также разделите --accelerator.gradient_accumulation.steps и количество шагов на число серверов. См. раздел HSDP в руководстве по обучению на нескольких GPU.

Новый робот

Для нового робота начните со значений по умолчанию класса с помощью --policy.type и задайте поля ваших данных в командной строке, например:

lerobot-train \
  --policy.type=cosmos3_edge \
  --policy.pretrained_path=lerobot/Cosmos3-Edge \
  --policy.load_action_modules=false \
  --policy.domain_id=0 \
  --policy.chunk_size=32 \
  --policy.n_action_steps=32 \
  --policy.view_description='The left half shows the front camera; the right half shows the wrist-mounted camera.' \
  --dataset.repo_id=${HF_USER}/my_dataset \
  ...

Конфигурация базовой модели

Конфигурация базовой модели --policy.mot_backbone представляет собой одно значение командной строки. Передайте YAML-словарь только с полями, которые нужно изменить, например, модель с меньшим количеством слоёв для быстрого теста без предобученных весов:

--policy.type=cosmos3_edge --policy.mot_backbone='{text_config: {num_hidden_layers: 2}, vision_config: {num_hidden_layers: 1}}'

Опущенные поля сохраняют значения по умолчанию для размера или значения из загруженной конфигурации с --policy.path. Записывайте числа с плавающей точкой в виде 1.0e-6 (YAML считывает 1e-6 как строку), а поля, значением которых является словарь, например rope_parameters, указывайте полностью. Поля архитектуры должны соответствовать загружаемым весам.

Допобучение с PEFT (LoRA)

Cosmos3 поддерживает LoRA через интеграцию PEFT LeRobot (pip install -e ".[cosmos3,training,peft]"). По умолчанию LoRA адаптирует проекции внимания генерационного пути (q_proj_gen, k_proj_gen, v_proj_gen, o_proj_gen), а модули действий (action2llm, llm2action, action_modality_embed) обучаются полностью и сохраняются вместе с адаптером.

lerobot-train \
  --policy.type=cosmos3_nano \
  --policy.pretrained_path=lerobot/Cosmos3-Nano \
  --policy.load_action_modules=false \
  --policy.gradient_checkpointing=true \
  --policy.repo_id=${HF_USER}/Cosmos3-Nano-Policy-LIBERO_10-LoRA \
  --peft.method_type=lora \
  --peft.r=16 \
  --peft.lora_alpha=32 \
  --policy.optimizer_lr=5e-4 \
  --policy.optimizer_weight_decay=0 \
  --dataset.repo_id=lerobot/LIBERO_10-Cosmos3 \
  --accelerator.mixed_precision=bf16 \
  --tf32=false \
  --ema.type=power \
  --ema.sigma_rel=0.1 \
  --batch_size=4 \
  --steps=16000 \
  --output_dir=outputs/train/cosmos3_nano_libero_10_lora

• --peft.lora_alpha=32, а значения learning rate и weight decay соответствуют значениям из нативного рецепта LoRA для Cosmos3. Без --peft.lora_alpha PEFT использует значение 8.
• При использовании --policy.load_action_modules=false модули действий могут иметь другую форму (--policy.max_action_dim, --policy.num_embodiment_domains). Это работает только для полной дообучения: при перезагрузке запуска PEFT загружается базовая модель, которой требуются те же формы.
• --policy.train_gen_stream_only и --policy.freeze_vision_encoder не имеют эффекта при использовании PEFT: обучаются только адаптеры и модули действий.
• Не добавляйте проекции действий (action2llm, llm2action) в --peft.target_modules: это таблицы для каждого воплощения, которые читаются напрямую сгруппированным матричным умножением, поэтому LoRA не изменит их. Они уже обучаются полностью.
• Используйте значение по умолчанию float32 для --policy.dtype при работе с PEFT, чтобы модули действий, обучающиеся в полном объёме, сохраняли мастер-веса в float32.
• Встроенные рецепты не задают размер батча или расписание для LoRA. Команда сохраняет расписание LIBERO (линейное затухание до нуля на шаге 16000) с 4 образцами на шаг.
• Cosmos3 Nano с LoRA обучается на одном GPU объёмом 80 ГБ с использованием градиентного чекпоинтинга, занимая около 64 ГБ при 4 образцах на GPU (см. Требования к оборудованию).

Оценка

Оцените контрольную точку LIBERO на четырёх наборах:

lerobot-eval \
  --policy.path=lerobot/Cosmos3-Nano-Policy-LIBERO \
  --policy.dtype=bfloat16 \
  --tf32=false \
  --env.type=libero \
  --env.task=libero_spatial,libero_object,libero_goal,libero_10 \
  --env.observation_height=256 \
  --env.observation_width=256 \
  --eval.n_episodes=10 \
  --eval.batch_size=10 \
  --output_dir=outputs/eval/cosmos3_nano_libero

• Для контрольной точки собственного запуска обучения передайте веса EMA: --policy.path=outputs/train/cosmos3_nano_libero_10/checkpoints/last/pretrained_model_ema.
• --env.observation_height=256 --env.observation_width=256 отображает камеры с разрешением 256x256, как в обучающих данных.
• Среда LIBERO автоматически добавляет преобразование действий Cosmos3 в свои процессоры: действия rot6d размерностью 10D преобразуются обратно в действия axis angle размерностью 7D, используемые в LIBERO. При запуске политики вне lerobot-eval также создавайте процессоры среды с помощью make_env_pre_post_processors(env_cfg, policy_cfg) из lerobot.envs.factory.
• См. руководство LIBERO для получения информации о протоколе оценки и других вариантах.

Предсказанное видео

Cosmos3 предсказывает будущие кадры вместе с действиями. Передайте --policy.save_predicted_video=true, чтобы декодировать предсказанное видео каждого чанка с помощью VAE и записать pred_episode_*.mp4 рядом с отрендеренными видео eval_episode_*.mp4.

Cosmos3 Edge на задаче LIBERO-10 «положите чёрную миску в нижний ящик шкафа и закройте его». Слева: наблюдения от третьего лица и с запястья в ходе выполнения. Справа: видео, предсказанное политикой, с выборкой каждые 16 действий от текущего наблюдения.

Результаты

LIBERO

Успешность в замкнутом цикле на LIBERO. Cosmos3-Nano-Policy-LIBERO и Cosmos3-Edge-Policy-LIBERO обучены на четырёх наборах LIBERO (lerobot/Cosmos3-Nano-Policy-LIBERO, lerobot/Cosmos3-Edge-Policy-LIBERO). Cosmos3-Nano-Policy-LIBERO_10 и Cosmos3-Edge-Policy-LIBERO_10 обучены только на LIBERO-10 (lerobot/Cosmos3-Nano-Policy-LIBERO_10, lerobot/Cosmos3-Edge-Policy-LIBERO_10), при этом конфигурация обучения Cosmos3-Nano-Policy-LIBERO_10 следует рецепту LIBERO-10, описанному в техническом отчёте. Cosmos-Nano-TechReport — это успешность Cosmos3 Nano на LIBERO-10, обученного только на LIBERO-10, как указано в таблице 20 технического отчёта (MT-init, итерация 2000, 500 прогонов).

Цитирование

@techreport{nvidia2026cosmos3,
  title  = {Cosmos 3: Omnimodal World Models for physical AI},
  author = {{NVIDIA Cosmos Team}},
  year   = {2026},
  url    = {https://research.nvidia.com/labs/cosmos-lab/cosmos3/technical-report.pdf}
}

Лицензия

Реализация LeRobot следует лицензии Apache 2.0 LeRobot. Веса Cosmos3 и нативный код распространяются по лицензии OpenMDW-1.1.