How to train GR00T N1.5 on an SO-100

Read this first: N1.5 is a compatibility choice

GR00T N1.5 is the predecessor of N1.7 and is superseded by it on every axis that matters. It is kept selectable on this platform for exactly one job: reproducing results from projects that were started before N1.7 existed. If you are here because a paper, a thesis chapter or an old experiment series names N1.5 and you need a checkpoint that is comparable to that work, you are on the right page. If you are choosing a model for a fresh SO-100 project, stop here and read /train/groot-n1-7-on-so-100 instead; it is the same workflow with a far better recipe.

The two versions share everything that touches your data. Same LeRobot v2.1 dataset format, same training form, same A100 80 GB tier, same deployment path back onto the arm. What differs is the model and its default schedule, which is why switching between them later is a dropdown and one more rented run, never a re-record.

What you need before starting

• A calibrated SO-100 with all six STS3215 bus servos responding, powered from its 7.4 V supply
• The camera setup of the original run, in the original positions, if the point is comparability
• The desktop client or CLI paired to your account
• The dataset of the original run as LeRobot v2.1, or a new set of at least 50 reviewed episodes of one task
• Billing enabled, because N1.5 is cloud-only and rents the same A100 80 GB tier as N1.7
• The original run’s recorded settings, if you still have them: step count, learning rate and accumulation belong in your notes, not your memory

If the arm itself is not settled yet, /learn/so-100-getting-started covers assembly and calibration, and /so-100/data-collection covers what a reviewable episode looks like. Neither page changes because the model is a version older.

The dataset rules are identical to N1.7

N1.5 accepts LeRobot v2.1 and rejects v3.0, exactly like its successor. The rejection arrives after the queue: the job waits for an A100, flips to RUNNING, then dies within the first minutes without writing a single loss value. Since the client records v2.1 by default, this mostly bites datasets imported from somewhere else, and it is worth ruling out in five seconds before you rent anything.

# The only field that decides whether GR00T will load the set
grep codebase_version path/to/dataset/meta/info.json
#   "codebase_version": "v2.1"   -> fine
#   "codebase_version": "v3.0"   -> convert before uploading

The 50-episode floor also carries over unchanged. It is not enforced by the trainer, it is where fine-tuning a 3-billion-parameter model on this class of arm stops memorizing start positions and starts learning the task. For a reproduction the question is simpler still: use the same dataset as the original run wherever you can. Re-recording “an equivalent set” quietly changes lighting, camera pose and demonstration style all at once, and then the comparison you were trying to protect is gone before training starts.

The conservative defaults, and why you leave them alone

N1.5 pre-fills a schedule that looks strange next to every other model on the platform: batch size 1, learning rate 1e-5, 2000 steps, 16 gradient accumulation steps. Multiplied out that is an effective batch of 16 and roughly 32 000 sample views per run, a twentieth of what N1.7’s defaults show the optimizer. It is a cautious compatibility recipe, not a tuned one.

For a reproduction, that caution is the point. The defaults are the known quantity that older runs on this platform started from, so a reproduction keeps them unless the original run recorded something different. If it did, match the original numbers, not the form. The one thing you cannot match is the seed: the GR00T fine-tuning entry point does not take one, for N1.5 exactly as for N1.7, so two runs on identical data will differ slightly and your comparison has to tolerate that.

Start the run

1. 1
   Select the dataset of the original run

   On the Training page, pick the exact dataset revision the earlier result used. If several revisions exist, the episode count on the card is the fastest way to tell them apart, and it is worth the ten seconds every time.

2. 2
   Choose GR00T N1.5 as the model

   It sits next to N1.7 in the model list and requests the same A100 80 GB tier. The form pre-fills the conservative schedule described above the moment you select it.

3. 3
   Restore the original hyperparameters

   Defaults if the original ran on defaults, otherwise the recorded values, with max steps the field most worth double-checking. This is the whole difference between reproducing a run and merely training the same model.

4. 4
   Start it and wait out the queue

   The pool buys A100 80 GB capacity on the spot market, so queue time tracks the market, not your dataset. Nothing is billed while the job sits in QUEUED.

   bash

   # The same start over the hosted MCP server; the model id is groot1.5
   curl -sS https://www.ay-robots.com/api/mcp \
     -H "Authorization: Bearer ayr_live_..." \
     -H "Content-Type: application/json" \
     -d '{
       "jsonrpc": "2.0",
       "id": 1,
       "method": "tools/call",
       "params": {
         "name": "start_training",
         "arguments": {
           "dataset_id": "ds_8f21c4",
           "policy_name": "so100-sort-groot15-repro1",
           "model_id": "groot1.5",
           "max_steps": 2000,
           "confirm_spend": true
         }
       }
     }'

5. 5
   Watch the opening of the run, then leave it

   The loss should move within the first few hundred steps. A curve that is flat from step one means the dataset did not load the way you assumed, and cancelling early costs minutes of A100 time instead of hours.

6. 6
   Keep the checkpoints the comparison needs

   For a reproduction that usually means the same checkpoint indices you evaluated last time, not just the final one. Save steps decided what exists; your notes decide what matters.

Cost: the same tier as N1.7, usually less of it

N1.5 requests the A100 80 GB tier, which currently runs 1.20 to 2.00 USD per hour on the spot market, with a typical run on this tier landing between 3 and 6 hours, about 4 to 12 USD. A pure defaults run sits at the friendly end of that band, simply because 2000 steps is a short schedule; a reproduction that restores a longer original step count moves through the band accordingly. The prices float day to day, which is why every number here is a range.

The uncomfortable part of the price is what it buys. N1.5 holds the same 80 GB card as N1.7 at the same hourly rate and returns less model for it. For a reproduction that trade is correct, because comparability is the product. For anything else it is the clearest single argument in the catalog for selecting the newer version.

Reading the run while it trains

The run page shows the loss curve, learning rate, gradient norm and the GPU’s utilization, VRAM, temperature and power. Two habits matter for an N1.5 reproduction in particular. First, expect the curve to look different from an N1.7 run even on identical data; the recipe sees a fraction of the samples, so comparing the two curves tells you about the schedules, not about your dataset. Second, if you still have the loss curve of the original run, compare shapes, not values: without a seed the numbers will not line up point for point, but a curve that falls and flattens in the same region is what a healthy reproduction looks like.

• Loss falls, then flattens: normal, for this model as for any other
• Loss flat from the first step: stop the run, the data did not load as intended
• Job FAILED within minutes and the page has no chart: almost always the LeRobot v3.0 rejection described above
• Utilization low while VRAM sits high: expected more often here than on N1.7, since batch 1 with accumulation is not a shape that keeps an 80 GB card busy

Back onto the arm, against the original protocol

Deployment is unchanged from every other model: pick a checkpoint on the policy, start inference from the client, and the SO-100 needs nothing new. At about 165 ms per action step the arm makes roughly six decisions a second, 13 ms slower per step than N1.7, which is well inside the noise of everything else in the loop and not something you will see by eye.

Evaluation is where a reproduction is won or lost. Run the original protocol, unchanged: the same number of attempts, the same reset procedure, the same object positions, the same task sentence word for word. Twenty attempts with varied start positions is the house standard if the original never wrote one down. The moment you improve the protocol you have disconnected the new number from the old one, and the entire reason for training N1.5 was that connection. The full evaluation loop is on /learn/run-your-first-policy.

If the point of the exercise is a before-and-after against N1.7, train the N1.7 side at its own defaults rather than copying N1.5’s schedule across, and give both the identical evaluation. /compare/groot-n1-7-vs-groot-n1-5 walks through that comparison in full, including why copying the conservative schedule to N1.7 makes the newer model look broken.

Troubleshooting

Frequently asked questions