Как да обучите GR00T N1.7 на собствен SO-100 набор от данни

NVIDIA предоставя пример за фино настройване точно за ръката, която вероятно притежавате. Във хранилището на Isaac-GR00T има папка, наречена demo_data/cube_to_bowl_5: пет епизода, 4148 кадъра при 30 кадъра в секунда, вече записани като LeRobot v2.1, със съответстваща конфигурация на модалност под examples/SO100/. Неговият meta/info.json докладва robot_type: so101_follower, което в LeRobot е същият клас конфигурация като so100_follower. Това е наистина полезно, защото означава, че референтният път за GR00T N1.7 на шест-степени на свобода хоби ръка се поддържа от хората, които са написали модела. Това не е намалена хуманоидна демонстрация, а същата ръка.

Лошата новина е разстоянието между I recorded 60 episodes и the arm does the task. Има около шест места, където този пайплайн се проваля тихо, а не шумно, и четири от тях се намират във файлове, които повечето хора никога не отварят: meta/modality.json, конфигурацията на Python данните, meta/relative_stats.json, и собствения низ за версия на набора от данни. Това ръководство описва ръчния маршрут от край до край с реалните команди, след което показва същата задача като форма на AY-Robots. Всичко по-долу е проверено спрямо основния клон на Isaac-GR00T към 20 август 2026 г. (линията n1.7-release) и lerobot 0.6.1, публикуван в PyPI на 3 август 2026 г. Разработката нагоре по веригата се движи бързо и където е преименуван флаг, тази статия го отбелязва.

Какво всъщност е GR00T N1.7

GR00T N1.7 е визуално-езиков-действен модел с двусистемната архитектура, описана в оригиналния доклад GR00T N1: визуално-езиков модул, който чете камерите и инструкцията, и дифузионен трансформатор, който превръща това в блок от непрекъснати моторни команди. N1.7 замени първата половина. Гръбнакът Eagle от N1.6 е премахнат, заменен с nvidia/Cosmos-Reason2-2B на архитектура Qwen3-VL, а моделът е предварително обучен на приблизително 20 000 часа егоцентрично човешко видео в допълнение към данните от робота. Собственото описание на NVIDIA посочва цифрата от 20 854 часа и съобщава, че преминаването от 1k на 20k часа повече от удвоява средното изпълнение на задачи.

Втората половина също се промени, по начини, които са важни за вашето изпълнение. Главата за действие намаля от 32 дифузионни слоя на 16, предвиденият блок от действия нарасна от 16 стъпки на 40, а максималната ширина на състоянието и действието се увеличи от 29 на 132. Тези три числа идват от дневника на промените в README на хранилището; собствената публикация на NVIDIA за стартиране все още описва Система 1 като 32-слоен DiT, така че където двете не съвпадат, доверете се на хранилището, което предстои да клонирате. Действията по подразбиране се изразяват в относително краен ефектор пространство, делта от текущата поза, а не абсолютни цели, което позволява на научените от човешко видео манипулационни априорни знания да се прехвърлят в управлението на робота. Самата глава е съвпадение на потока дифузионен трансформатор, от същото семейство като Pi0.5, но с различен гръбнак пред него. Ако все още сте на предишното поколение, N1.7 срещу N1.5 обхваща дали надстройката оправдава преработката на вашата конвейерна линия.

Последните три реда обясняват по-голямата част от разочарованието, което хората съобщават. Заглавните 27.9 ms са за TensorRT енджин на H100 с една камера и четири стъпки за премахване на шума. Обикновеният PyTorch на същата карта е 85.8 ms, а картата на модела посочва разлика от 3.08x. Нито едно от числата не включва обслужващ слой, втора камера или мрежов скок. Цитираните от AY-Robots 152 ms на стъпка на действие за обслужвания GR00T N1.7 са стойността с обслужване в цикъла, а пътуване до публичен интернет се добавя отгоре. Повече за това в края. За числата до други модели, GR00T N1.7 срещу Pi0.5 и GR00T N1.7 срещу SmolVLA ги представят един до друг.

Какво е необходимо за изпълнението, преди да въведете каквото и да било

Стъпка 0: самите епизоди

Всичко по-долу предполага, че вече имате записани епизоди. Ако нямате, това е истинската първа стъпка и тя е тази, която решава колко добър може да бъде резултатът, защото обучение чрез имитация не може да възстанови информация, която не е в данните. Първо калибрирайте и двете рамена, след това управлявайте последователя с водещо рамо докато lerobot-record записва parquet файловете и потоците от камери. Ако калибрирането е неточно, стойностите на ставите във вашия набор от данни описват малко по-различен робот от този, който по-късно ще изпълни политиката, и никакво обучение не може да поправи това.

lerobot-record \
    --robot.type=so100_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so100_leader \
    --teleop.port=/dev/ttyACM1 \
    --teleop.id=my_leader_arm \
    --dataset.repo_id=${HF_USER}/cube-into-bowl \
    --dataset.num_episodes=60 \
    --dataset.single_task="put the cube in the yellow bowl" \
    --display_data=true

Собственият съвет на LeRobot е да запишете поне 50 епизода с около 10 за всяко местоположение на обекта, да държите камерите фиксирани и да поддържате последователно поведението на захващане. Добавете вариации по-късно, не в началото. Правилото, което си струва да запомните: ако не можете да изпълните задачата сами само от изображенията на камерата, политиката също не може. За специфичната за рамото настройка, начало с SO-100 и страницата на SO-100 LeRobot обхващат портове, калибриране и индекси на камери. На AY-Robots можете да направите това и през интернет от браузъра, използвайки телеоперация и да записвате директно от сесията.

Стъпка 1: наборът от данни трябва да е LeRobot v2.1

Това е най-често срещаната пречка. Текущата CODEBASE_VERSION във `main` е v3.0, така че всичко, което запишете днес с текущия набор от инструменти, излиза като v3.0. Зареждащият модул на GR00T очаква v2. Хранилището е изрично защо: много набори от данни нагоре по веригата, като DROID, LIBERO и Bridge, са публикувани във v2, а нативната поддръжка за двете е планирана, но не е доставена. Така че конверсията е ваша отговорност и тя работи в собствен виртуален енвайрънмънт по конкретна причина: scripts/lerobot_conversion носи свой собствен `pyproject`, който изисква Python 3.10 или 3.11 и фиксира `lerobot` към един `git commit`, докато самият Isaac-GR00T изисква Python 3.12. Инсталирайте конвертора от корена на хранилището и вместо това ще получите пакета gr00t , което е грешката, за която предупреждава неговият README. Ако сте нов във формата, набор от данни LeRobot в речника обяснява какво всъщност има вътре.

# from the Isaac-GR00T repo root
cd scripts/lerobot_conversion
uv venv
source .venv/bin/activate
uv pip install -e . --verbose

# pulls the dataset from the Hub and writes a v2.1 copy into the default cache
python convert_v3_to_v2.py --repo-id <your-hf-user>/<your-dataset>

# or, back in the repo root, keep it next to the SO-100 example
uv run --project scripts/lerobot_conversion \
  python scripts/lerobot_conversion/convert_v3_to_v2.py \
  --repo-id <your-hf-user>/<your-dataset> \
  --root examples/SO100/my_dataset_lerobot

Структурата, която GR00T изисква след преобразуване, е класическото v2 оформление: meta/info.json, meta/episodes.jsonl, meta/tasks.jsonl, parquet файлове под data/chunk-000/, MP4 файлове под videos/chunk-000/observation.images./, и един допълнителен файл, който стандартният LeRobot не притежава. Този допълнителен файл е мястото, където се намират повечето от останалите грешки.

Стъпка 2: modality.json, шестте числа, които решават всичко

В набор от данни на LeRobot състоянието на робота и действието се съхраняват като плоски float32 масиви. За SO-100 и двете имат форма [6]: пет стави на ръката и един захват. Демонстрационният набор от данни ги нарича shoulder_pan.pos, shoulder_lift.pos, elbow_flex.pos, wrist_flex.pos, wrist_roll.pos, gripper.pos, но тези имена се намират в info.json и нищо във файла parquet не указва кой индекс е кой. meta/modality.json предоставя това съпоставяне и GR00T няма да се обучава без него. Ето този, който хранилището предоставя за SO-100, дословно.

{
  "state": {
    "single_arm": {
      "start": 0,
      "end": 5
    },
    "gripper": {
      "start": 5,
      "end": 6
    }
  },
  "action": {
    "single_arm": {
      "start": 0,
      "end": 5
    },
    "gripper": {
      "start": 5,
      "end": 6
    }
  },
  "video": {
    "front": {
      "original_key": "observation.images.front"
    },
    "wrist": {
      "original_key": "observation.images.wrist"
    }
  },
  "annotation": {
    "human.task_description": {
      "original_key": "task_index"
    }
  }
}

Копирайте го във вашия конвертиран набор от данни на meta/modality.json и преименувайте видео ключовете на това, както всъщност се наричат вашите камери. Ако сте записали с една горна камера, наречена top, тогава original_key е observation.images.top и приятелското име е това, което ще реферира вашата конфигурация на данни. Двете трябва да съвпадат и нито едно от тях не проверява другото вместо вас. Анотацията на езика е по-лоша, защото един и същ ключ трябва да се появи на три места.

Стъпка 3: конфигурацията на данните, относителна ръка и абсолютен грипер

Конфигурацията на модалността е Python файл, а не JSON, защото тя също така определя как се представя всяка група действия. Това е частта от работния процес на N1.7, която не съществуваше в същата форма в N1.5, и частта, която си струва да се прочете два пъти. Доставената SO-100 конфигурация предвижда петте стави на ръката като RELATIVE делти от текущото състояние и захвата като ABSOLUTE целева позиция, тъй като двоичен сигнал отворено-или-затворено се държи по-добре като цел, отколкото като делта.

from gr00t.configs.data.embodiment_configs import register_modality_config
from gr00t.data.embodiment_tags import EmbodimentTag
from gr00t.data.types import (
    ActionConfig, ActionFormat, ActionRepresentation, ActionType, ModalityConfig,
)

so100_config = {
    "video": ModalityConfig(
        delta_indices=[0],                       # current frame only
        modality_keys=["front", "wrist"],        # must match modality.json
    ),
    "state": ModalityConfig(
        delta_indices=[0],
        modality_keys=["single_arm", "gripper"],
    ),
    "action": ModalityConfig(
        delta_indices=list(range(0, 16)),        # predict 16 future steps
        modality_keys=["single_arm", "gripper"],
        action_configs=[
            ActionConfig(rep=ActionRepresentation.RELATIVE,   # arm joints
                         type=ActionType.NON_EEF,
                         format=ActionFormat.DEFAULT),
            ActionConfig(rep=ActionRepresentation.ABSOLUTE,   # gripper
                         type=ActionType.NON_EEF,
                         format=ActionFormat.DEFAULT),
        ],
    ),
    "language": ModalityConfig(
        delta_indices=[0],
        modality_keys=["annotation.human.task_description"],
    ),
}

register_modality_config(so100_config, embodiment_tag=EmbodimentTag.NEW_EMBODIMENT)

Два детайла тук ще ви струват един ден, ако не ги знаете. Първо, action_configs е позиционен: документацията изисква същата дължина и същия ред като modality_keys, и те са директни относно последствията от грешка, а именно, че грешното представяне се прилага мълчаливо. Вашият захват се обучава като делта, а ръката ви като абсолютна цел, и няма съобщение за грешка. Второ, register_modality_config твърди, че тагът не е вече регистриран, така че втора NEW_EMBODIMENT конфигурация в същия Python процес умира с Embodiment tag ... already registered. Не можете да импортирате две от тези в един скрипт. Трето правило се прилага по-късно, при разгръщане: delta_indices на действието трябва да бъде непрекъснат диапазон, започващ от нула. Разреден прозорец като [0, 4, 8] се отхвърля, защото всичко надолу по веригата индексира предсказания блок линейно и иначе би изпълнило грешни редове.

Стъпка 4: средата

N1.7 премести хранилището в и Python 3.12. Старият път с conda плюс pip install -e . все още съществува в сгъната секция на README, но предупреждава, че GPU зависимостите, включително flash-attn и TensorRT, може да изискват ръчна инсталация. Използвайте uv, освен ако нямате конкретна причина да не го правите. По отношение на flash-attn, един детайл спестява объркване: ще видите Installing flash-attn отпечатано при всяко uv run. То не се преизгражда. uv превалидира URL-закрепен wheel, който вече е кеширан, и това отнема две или три секунди.

1. 1
   Инсталирайте git-lfs, след това клонирайте със субмодули

   git-lfs е задължителен, не по избор. Без него parquet файловете в demo_data/ се изтеглят като указателни пънове и демонстрационното изпълнение се проваля на набор от данни, който изглежда присъства в списъка с файлове.

   bash

   sudo apt install git-lfs && git lfs install
   git clone --recurse-submodules https://github.com/NVIDIA/Isaac-GR00T
   cd Isaac-GR00T

2. 2
   Инсталирайте uv и синхронизирайте средата

   Инсталацията по подразбиране изтегля GPU зависимостите, включително flash-attn и TensorRT. На чисто A100 или H100 изображение това е най-дългата единична стъпка, така че я направете, преди да обърнете внимание на нещо друго.

   bash

   curl -LsSf https://astral.sh/uv/install.sh | sh
   sudo apt-get update && sudo apt-get install -y ffmpeg
   uv sync --python 3.12
   uv run python -c "import gr00t; print('GR00T installed successfully')"

3. 3
   Автентикирайте се срещу Hugging Face

   Направете това преди първото стартиране на обучението, а не след като се провали осем минути по-късно.

   bash

   uv run huggingface-cli login   # or: export HF_TOKEN=<your_token>

4. 4
   Проверка за изправност на предоставените SO-100 демонстрационни данни

   Преди да докоснете собствения си запис, изпълнете 2000 стъпки на demo_data/cube_to_bowl_5. Това са пет епизода, завършва бързо и доказва средата, а не вашите данни. Ако това изпълнение се провали, нищо, което направите с вашия набор от данни, няма да помогне.

   bash

   CUDA_VISIBLE_DEVICES=0 uv run python \
       gr00t/experiment/launch_finetune.py \
       --base-model-path nvidia/GR00T-N1.7-3B \
       --dataset-path demo_data/cube_to_bowl_5 \
       --embodiment-tag NEW_EMBODIMENT \
       --modality-config-path examples/SO100/so100_config.py \
       --num-gpus 1 \
       --output-dir /tmp/test_finetune \
       --max-steps 2000 \
       --global-batch-size 32 \
       --dataloader-num-workers 4

Стъпка 5: командата за фино настройване и какви са нейните флагове по подразбиране

Заменете демонстрационния набор от данни с вашия и добавете настройките, които всъщност искате. По-долу е пълната форма, която хранилището използва в собствения си урок за ново въплъщение, включително флаговете за аугментация и контролни точки, които краткият пример в README пропуска. Това е в тесен смисъл: езиковата основа и визуалният енкодер остават замразени, а това, което се обучава, е проекторът и дифузионната глава за действие.

export NUM_GPUS=1
CUDA_VISIBLE_DEVICES=0 uv run python \
    gr00t/experiment/launch_finetune.py \
    --base-model-path nvidia/GR00T-N1.7-3B \
    --dataset-path ./my_dataset_lerobot \
    --embodiment-tag NEW_EMBODIMENT \
    --modality-config-path examples/SO100/so100_config.py \
    --num-gpus $NUM_GPUS \
    --output-dir /tmp/so100 \
    --save-total-limit 5 \
    --save-steps 2000 \
    --max-steps 20000 \
    --use-wandb \
    --global-batch-size 32 \
    --color-jitter-params brightness 0.3 contrast 0.4 saturation 0.5 hue 0.08 \
    --dataloader-num-workers 4

Този последен ред не е печатна грешка. launch_finetune.py е tyro CLI, генериран от dataclass, и този dataclass няма поле за seed. README отделно отбелязва 5 до 6 процента разлика между изпълненията, причинена от недетерминистично уголемяване на изображенията. Две изпълнения с идентични флагове няма да произведат идентични контролни точки, което е от голямо значение, когато се опитвате да решите дали промяната на хиперпараметър е помогнала или просто сте имали късмет. За сравнение, собственият обучител на lerobot по подразбиране използва seed 1000, а рецептата LeRobot GR00T подава --seed=42 изрично.

Какво струва едно изпълнение от 20000 стъпки

GR00T N1.7 се нуждае от 80 GB карта, така че въпросът за цената има тесен отговор. На AY-Robots обучителят groot1.7 работи на ниво A100 80 GB или H100 80 GB, където едно изпълнение отнема 3 до 6 часа при 1.20 до 2.00 USD на час на спот пазара. Това е приблизително 4 до 12 USD за стандартната задача от 20000 стъпки. Същата задача на SmolVLA или ACT се изпълнява на 24 GB карта при 0.30 до 0.60 USD на час и 1 до 3 USD на изпълнение. Това е истинският компромис: GR00T струва около четири пъти повече на опит и не можете да го стартирате на 4090 под бюрото си.

Минимумът от 50 епизода е долна граница, а не цел. Собствените ЧЗВ на NVIDIA са по-взискателни: приблизително 100 траектории за просто взимане и поставяне на фиксирано място, 500 или повече за сложни или многостъпкови сцени и 100 до 500 за фина манипулация. Ако сте на 20 епизода, прекарайте следобеда в записване, вместо вечерта в настройване. Ръководството за събиране на данни обхваща какво отличава полезния епизод от пропиления, запишете първия си набор от данни е кратката версия, а събиране на данни за SO-100 е специфичната за ръката.

Стъпка 6: оценка в отворен цикъл, преди да докоснете ръката

Не поставяйте нова контролна точка на физическа ръка, за да разберете дали обучението е проработило. Първо стартирайте оценката с отворен цикъл. Тя преиграва записан епизод, изисква действия от модела на всяка стъпка и изобразява предсказанието спрямо реалността с MSE и MAE. Не струва нищо и улавя грешките в картографирането от стъпки 2 и 3.

uv run python gr00t/eval/open_loop_eval.py \
    --dataset-path ./my_dataset_lerobot \
    --embodiment-tag NEW_EMBODIMENT \
    --model-path /tmp/so100/checkpoint-20000 \
    --traj-ids 0 \
    --execution-horizon 16 \
    --steps 400 \
    --modality-keys single_arm gripper

Хранилището умишлено отказва да публикува целево MSE за персонализирани данни и това е правилното решение: числото зависи от вашите единици за действие, вашата задача и размера на вашия набор от данни, така че праг, копиран от чужда ръка, не означава нищо. Това, което е смислено, е тенденцията. Ето референтното изпълнение, което хранилището документира на един H100 с демонстрационния набор от данни от пет епизода и 2000 стъпки.

Формата е сигналът, а не абсолютните стойности. Грешката трябва да намалява постоянно, докато се натрупват натрупват. Усреднено за всичките пет епизода на обучение, а не само за траектория 0, крайната контролна точка на хранилището отбеляза приблизително 7.5 MSE и 1.5 MAE, така че дори референтният прогон се тълкува различно в зависимост от това кои епизоди усреднявате. Запишете собствената си базова линия с непроменената демо команда, преди да промените каквото и да е във вашите данни: ако не можете да възпроизведете известен добър прогон, не можете да различите грешка в настройката от проблем с данните. Хранилището също така картографира често срещаните симптоми към причините, като всяка от тях е оперативна, а не грешка в модела.

Другият път: lerobot-train вместо Isaac-GR00T

Текущата версия на LeRobot, 0.6.1 в PyPI от 3 август 2026 г., предлага втори и доста различен начин за фино настройване на същите базови тегла. LeRobot излага GR00T N1.7 като тип политика и го обучава чрез собствената си lerobot-train входна точка. Тук са важни две неща. LeRobot CLI е набор от конзолни скриптове, така че всичко, което четете и казва python lerobot/scripts/train.py е остаряло и няма да работи. И LeRobot премахна поддръжката за GR00T N1.5 изцяло, отхвърляйки N1.5 контролни точки и конфигурации с бележка за миграция, така че ако имате нужда от N1.5 чрез LeRobot, трябва да фиксирате lerobot==0.5.1, последната версия, която го поддържа, публикувана на 7 април 2026 г.

pip install "lerobot[groot]" "lerobot[training]"
hf auth login

lerobot-train \
  --dataset.repo_id=$HF_USER/$DATASET_NAME \
  --dataset.image_transforms.enable=true \
  --policy.type=groot \
  --policy.device=cuda \
  --policy.base_model_path=nvidia/GR00T-N1.7-3B \
  --policy.embodiment_tag=new_embodiment \
  --policy.chunk_size=16 \
  --policy.n_action_steps=16 \
  --policy.use_relative_actions=true \
  --policy.relative_exclude_joints='["gripper"]' \
  --policy.use_bf16=true \
  --seed=42 \
  --batch_size=64 \
  --steps=20000 \
  --save_freq=5000 \
  --output_dir=$OUTPUT_DIR

Два начина за получаване на една и съща контролна точка

Връщане на контролната точка обратно на рамото

Isaac-GR00T използва разделение сървър-клиент през ZMQ. Политиката работи на GPU, а тънък клиент на машината на робота изпраща наблюдения и получава части от действия. Примерът със SO-100 е достатъчно пълен за копиране: стартирайте run_gr00t_server.py с вашата контролна точка и --embodiment-tag NEW_EMBODIMENT, след това изпълнете eval_so100.py от страната на робота със серийния порт, идентификатора на робота, индексите на камерата и езиковата инструкция. Имената на камерите в тази команда трябва да съответстват на приятелските имена от вашия modality.json, а не на номерата на устройствата на ОС.

# GPU side
uv run python gr00t/eval/run_gr00t_server.py \
  --model-path /tmp/so100/checkpoint-20000 \
  --embodiment-tag NEW_EMBODIMENT \
  --device cuda:0 \
  --host 0.0.0.0 --port 5555

# robot side, from gr00t/eval/real_robot/SO100
uv run --no-sync python eval_so100.py \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM2 \
  --robot.id=orange_follower \
  --robot.cameras="{ front: {type: opencv, index_or_path: 6, width: 640, height: 480, fps: 30}, wrist: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
  --policy_host=localhost --policy_port=5555 \
  --lang_instruction="put the cube in the yellow bowl"

Сега честната част за това къде работи политиката, защото обучението и обслужването имат различни хардуерни истории. Фината настройка изисква 40 GB или повече. Инференцията не: README го поставя на 16 GB или повече и изрично посочва RTX 4090, така че карта, която вече притежавате, може да обслужва контролен пункт, който никога не би могла да произведе. Това, което решава дали политиката се усеща отзивчива, не е VRAM, а къде се намира сървърът. На AY-Robots GR00T N1.7 е само в облак, така че контролният цикъл плаща двупосочно пътуване през публичен интернет в допълнение към 152 ms на стъпка на действие, и само SmolVLA и ACT също работят локално. За бавно взимане и поставяне отдалечен под е поносим. За всичко реактивно не е: политиката става колеблива по начин, който изглежда точно като провал в обучението и не е такъв. ACT при 20 ms на стъпка на действие е моделът, който толерира най-тесния цикъл, SmolVLA е на 245 ms, и никакво количество настройка на латентността не може да компенсира двупосочно пътуване, което вече е изразходвано. Стартирайте първата си политика преминава през обслужващата страна от край до край.

Какво всъщност се обърква

• GatedRepoError при първото стартиране. Нямате предоставен достъп до nvidia/Cosmos-Reason2-2B или не сте се удостоверили. Това се случва, след като тактовата честота на GPU вече е стартирала.
• Наборът от данни е отхвърлен при зареждане. Почти винаги е набор от данни v3.0. Конвертирайте го до по-стара версия. Вижте отхвърлен набор от данни като v3.
• IndexError относно несъответстващи булеви измерения. Променихте delta_indices и не генерирахте отново статистиките.
• Недостатъчна памет при пакет 32. Намалете --global-batch-size и увеличете --gradient-accumulation-steps, или намалете --num-shards-per-epoch, което конфигурацията изрично предлага, когато VRAM е ограничена. Вижте недостатъчна памет по време на обучение.
• Загубата намалява, политиката не прави нищо. По подразбиране няма разделяне за валидация, така че чистата крива на обучение доказва много малко. Тази страница обхваща диагностиката.
• Работи във вашата настройка и никъде другаде. Очаквано с малък набор от данни, заснет при едно условие на осветление. NVIDIA препоръчва аугментация с цветен джитър плюс 20 до 50 епизода при различно осветление. Повече тук.
• Грайферът никога не се затваря правилно. Проверете дали действието на грайфера е ABSOLUTE, а ставите на ръката са RELATIVE, в този ред в action_configs. Грайферът не се затваря изброява другите причини.
• Камерата тихо отпада по време на запис. Епизодът все още се запазва и видео ключът все още съществува, затова това е неприятно. Камерата не е открита обхваща това.

Пълният индекс на режимите на отказ се намира на . Ако избирате между модели, вместо да отстранявате грешки в един, и имат бенчмарк числа с приложени източници, а е сравнението, от което повечето хора всъщност се нуждаят, защото това е изборът между модел, който можете да обучите на картата под бюрото си, и такъв, за който трябва да наемете 80 GB възел за фина настройка. За информация защо тези модели се държат по този начин, и си струва да се прочетат първо. И ако все още не притежавате ръка, предава физически SO-100 без регистрация.