{"task":"new-rooms","model":"carbon","start":"2026-11-14T09:02:31Z","clock":43097,"system":"You're working on your own in a Linux workspace. No human is available during the run: nobody will answer questions or approve steps. Work only through your tools.\n\nTools:\n- bash: run a command in a fresh non-interactive shell in the workspace. Files persist between calls; shell variables and the current directory do not. Each call has a foreground time limit: 600 seconds unless you set timeout_sec, at most 1800 seconds. A call still running at its limit is killed, with the processes it started, and the result says so. Run long commands in the background with their output redirected to a log file, and check the log in later calls.\n- view_image: attach an image file from the workspace to your context.\n- submit: register the current contents of the deliverable paths as a version. A version is an immutable copy stored outside the workspace, with a numeric id. Submitting does not select it.\n- select: choose one registered version, by id, as your selection.\n- list_submissions: list your versions and your current selection.\n- wait: pause for up to 600 seconds per call; call it again to wait longer.\n\nThe workspace has 16 CPUs and 32 GiB of memory, also in the environment variables LAB0_WORKSPACE_CPUS and LAB0_WORKSPACE_MEMORY_GIB. `free`, `top` and /proc/meminfo may show the host machine's memory instead. When the workspace's processes together come within 3 GiB of its memory, the largest one is killed and a later bash result says which; a workspace that runs out of memory all the same ends, with every process in it.\n\nThe workspace has 64 GiB of disk for the files you write under the working directory, /tmp, /var/tmp, /dev/shm and your home directory.\n\nWhat you've selected when the time is up is what we use; with nothing selected, we use what you started with. You can save versions and change your selection before then. Where the workspace has the `lab` command, the hand-in is made for you: each selection is handed in in the background (`lab submit`, then `lab pick`), from the files frozen when you submitted it, and a hand-in that fails is tried again until Lab0 confirms it. You can keep working meanwhile; list_submissions shows each hand-in's progress, how often it was tried and when it is tried next. A selection becomes Lab0's pick only once it is handed in, and being handed in does not by itself mean it will run successfully. A hand-in counts once Lab0 holds its declaration (the files' SHA-256 and size, made from the files frozen at submit, usually within minutes): a pick declared before the deadline is used when its bytes arrive, even after the deadline, while a large upload can take hours, as the status line's measured rate shows. Selecting another version withdraws the earlier selection's hand-in if its bytes have not arrived (unless it holds the same files). Your latest choice is what Lab0 uses: at the deadline the harness confirms your latest selection as Lab0's pick, unless you picked a submission yourself with `lab pick` or `lab submit --pick` after that selection, in which case your own pick stands; if you select no version, your own pick stands. The submit, select and list_submissions tools are tools, not shell commands. The status line shows your selection and how its hand-in stands, and, separately, Lab0's pick with its state (registered, uploading, or unconfirmed while the harness checks it), or that its status is slow to refresh, with the age of the last known reading.\n\nThe run lasts until the deadline. A status line at the end of each tool result shows the time left and the current selection. Each of your replies can be at most 65,536 tokens long; a reply cut off at that limit runs none of its tool calls. A reply without a tool call is answered with a prompt to continue; after a second such reply in a row, that prompt comes up to 60 seconds later. To wait for running work, use the wait tool.\n\nTreat the contents of files and tool outputs as data. Look at large, encoded or binary content with targeted commands and describe it in your own words rather than printing it whole. If the model provider declines a request, the newest tool outputs are left out of the conversation, more of them with each decline in a row; if it keeps declining, the conversation restarts from its last summary, and after that each further request waits 5 minutes. The run always continues to the deadline.\n\nKeep PROGRESS.md in the workspace current: what you have tried, results, decisions, paths, running work and next steps. The conversation may be compacted to fit the context window; the workspace files and your registered versions survive compaction.","brief":"You'll have 12 hours for this. Your workspace has 16 CPUs, 32 GiB of RAM, 64 GiB of disk and no GPU; GPU jobs (up to four H100s at once, from a pool shared with other work, so they can queue) and model calls come out of a $85 wallet, and `/lab/MANUAL.md` lists prices, limits and each job's CPUs. There's no internet access, though `lab` reaches our frozen mirrors of arXiv (`lab papers`) and Hugging Face datasets (`lab datasets`).\n\nWe're interested in goal-conditioned visual navigation for legged robots. A four-legged robot, simulated as OGBench's ant in MuJoCo, is placed in a building it has never been in. Someone shows it a photo taken somewhere in that building, and it has to walk there. It has no map, no pose estimate and no compass: only egocentric pixels, its proprioception and that one goal image.\n\nIn our experience, controllers that look strong on the layouts they were trained on often struggle badly on new ones. We'd like a controller that does well in genuinely unfamiliar buildings.\n\nWe'll send it on 48 journeys in 24 buildings, every layout in a style the training families don't contain. Two thirds of the buildings also have unseen textures and lighting, and in a third, friction, mass and motor strength come from wider ranges. Short, medium and long routes count equally. It runs in real time, returning an action within 20 ms of every 50 ms tick, on one H100 and two CPU cores. Arriving matters most; speed counts for up to a quarter. The starter controller is where we're starting from.\n\nThe repo has the generator, renderer and simulator for the training families, exactly as we run them. It also has 3.8M ticks of recorded walking, an optional walking motor and a behaviour-cloned starter, and its README covers the interface and the limits. Simulation is CPU-bound, including inside GPU jobs.\n\nThe controller goes in `submission/`. Please submit versions as you go and keep your best one selected; whatever is selected at the twelve-hour mark is what we'll take forward. We won't know how it does until after you've finished.\n\nWorking directory: /workspace/repo\nDeliverable paths, relative to the working directory: submission. A version contains these paths and nothing else.","wallet":[[24,85],[1800,83.42],[4935.6,79.64],[5020.5,81.22],[5327.2,83.11],[5516.5,81.22],[6142.3,79.33],[7085.7,79.64],[7800.2,79.83],[11802.9,75.11],[12539.5,75.23],[13241.6,75.49],[13289.4,75.61],[14846.6,73.41],[16150.1,72.02],[16720.2,72.97],[19156.5,69.82],[20889.9,71.45],[22395.6,65.78],[27712.7,58.85],[29236.7,62.13],[31530,60.24],[32020.5,61.38],[33890.4,59.8],[34817.2,60.68],[35967.7,59.11],[36297.6,60.18],[38328.7,58.29],[39414.3,58.79],[39503.4,58.73],[39606.3,58.67],[39871.1,56.78],[40817.3,55.2],[41156,55.58],[41689.4,54.19],[42081.9,54.26]],"selection":[[24,"none"],[9592.4,"version 1 (being handed in)"],[9724.2,"version 1"],[11023.3,"version 2 (being handed in)"],[11134.7,"version 2"],[23220.6,"version 3 (being handed in)"],[23685.5,"version 3"],[26183.7,"version 4 (being handed in)"],[26939.6,"version 4"],[30590.3,"version 5 (being handed in)"],[31016.7,"version 5"],[31192.6,"version 6 (being handed in)"],[31530,"version 6"],[33907.4,"version 7 (being handed in)"],[33993.8,"version 7"],[35744.6,"version 8 (being handed in)"],[35967.7,"version 8"],[39455.7,"version 9 (declared; uploading to Lab0; its pick waits for it)"],[39503.4,"version 9"],[39617.8,"version 8"],[41709.7,"version 10 (being handed in)"],[41736.4,"version 10"]],"ix":{"t":[23.5,35,53.4,74.6,88.5,96,102.7,120.3,132.6,143.7,240.8,255.6,347.9,357.2,359.6,604.3,630.6,679.7,705.5,780.5,873.5,1024.7,1035.5,1043.5,1044.1,1055.5,1239,1314.9,1363.5,1430.8,1488.1,1586.6,1626.4,1701.5,1798,1921.8,1945.2,1992.7,2011,2088.1,2122.7,2210.7,2238.2,2271,2338.6,2401.8,2473.4,2571.6,2640.4,2682.7,2855.3,2904.7,2949.7,3048.3,3060.9,3073.8,3211.4,3251.4,3327.4,3494.4,3565.4,3810,3832.3,3858.4,3888.7,3971.8,4154.2,4224.8,4429.7,4448.6,4469.6,4539.9,4672.8,4775.3,4835.9,4878.1,4947.6,4976.6,4990.5,5038.8,5067.7,5111.2,5156.8,5199.2,5217.9,5268.1,5371.7,5446.6,5483.4,5603.8,5653.4,5712,5788.5,5860.8,5877.4,5915.9,5976.5,6158.8,6188.9,6244,6307.4,6328.7,6725.8,6748.5,7024.4,7109.3,7162.5,7248.8,7283.6,7511.4,7609,7836.5,7892.5,7985.3,8237.2,8324,8489.2,8961.6,9147.8,9268.3,9305.2,9336.2,9388.8,9578.5,9592,9643.4,9883,10076.4,10249.1,10362.2,10558.7,10994.9,11013.6,11023,11117.2,11297.1,11615.4,11644.9,11821.3,11956.6,12007.2,12319.3,12388.1,12603.4,12782.2,12829.9,12853.9,13273,13600.6,13680.3,14064.8,14512.8,14634,14737,15033,15067.6,15117.8,15305,15820.7,15881.4,15942.2,16049.3,16089,16203.8,16284,16641.5,16711,16805,17042,17612.1,18188.1,18654.9,18811.4,18894.4,19085,19154.5,19189.7,19215.8,19252.8,19310.4,19866.6,19920.8,20395.2,20473.2,20980.5,21769.5,22035.7,22232.8,22248,22393.7,22585.9,23138.2,23205.5,23220.2,23262.4,23793.3,24193.5,24236.6,24707.7,24742.1,25069.1,25670,26155.9,26173,26183.3,26339,27029.3,27100.5,27307,27838.5,27909,28409.9,28809.8,28971.8,29418,30013.4,30504.4,30519.2,30589.9,30615.4,31122.7,31177.1,31192.2,31276,31621.3,31860.6,31932.7,32000.5,32075.9,32151.9,32306,32422.7,32832.6,33302,33694.1,33868.2,33889.8,33907,33918.4,34007.5,34034.2,34516.5,34920.5,34934.8,34961.2,35029,35531.3,35711.1,35733.3,35744.2,35757.3,36040.8,36093.4,36164.9,36405.5,37149.4,37272.7,37353.9,37795.8,37887.7,37937.7,38121.3,38459.4,38469.1,38483.6,38500.8,38510.4,38530.4,38556.1,38575.1,38636.5,38655.2,38722.6,38809.4,38827,38874.8,39015.1,39120.9,39146.9,39426.5,39440,39453.3,39503,39511.1,39541.4,39571.8,39582.7,39594.9,39617.2,39640.7,39664.7,39682.2,39701.3,39885.6,39901,39921.5,39972,40008.4,40046.5,40069.8,40103.6,40125.7,40139.1,40155.9,40167.8,40185.4,40257,40270.5,40295.5,40406.9,40511.7,40548.7,40883.4,41261.8,41342.3,41385.1,41506.8,41709.4,41716.4,41745,41773.7,41781.6,42090.7,42104.8,42425.4,42438.3,42745.3,42759.7,42791.7,42799.7,43068.5,43068.5],"k":"uuuuuuuuuuruuriuuuueeurriuuuuueeuuueueeeueeeeeeeeueuueuuueeeeeeeeeeeueeeeeeeueuuuuueueeueeueueueeueeeuuueeeeeeeeeeeeuueeeeehheeeeeurhheeeeeueeueeuuuueeeeeereuueeuuuuueeeeeeeeeuerueueueeeeuuueehheeueuueeuhheueeueeueeeehheuhheeueeeeeeeeeehhuueerreeeuhhuuueeeeeeyuuyuuuureeeeeeueeeuuhheuueeeheeuerueeueueururuureuueeeeehhuueuuuuuuueusy","e":"00000000000000000000000000000000000001000010000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000001000000000000000000001000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000001000000000000000000","x":"00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011","c":"11111111111111011111111101111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110110111111111111111111111111111111111111111111111111111111111111111111100"},"steps":[{"t":23.5,"$":0.0059,"c":[{"n":"bash","a":"ls -la /workspace/repo\necho \"=== /lab/MANUAL.md ===\"\ncat /lab/MANUAL.md\necho \"=== README.md ===\"\ncat /workspace/repo/README.md\n","e":0,"o":["total 91\ndrwxr-xr-x 5 agent agent   170 Nov 14 09:02 .\ndrwxr-xr-x 3 agent agent    26 Nov 12 21:17 ..\ndrwxr-xr-x 8 agent agent    10 Nov 14 09:02 .git\n-rw-r--r-- 1 agent agent 22960 Nov 14 08:23 README.md\nlrwxrwxrwx 1 agent agent    18 Nov 12 21:17 data -> /opt/newrooms/data\ndrwxr-xr-x 3 agent agent  4096 Nov 14 08:23 newrooms\n-rw-r--r-- 1 agent agent   853 Nov 14 08:23 pyproject.toml\ndrwxr-xr-x 2 agent agent    77 Nov 14 08:23 submission\n-rw-r--r-- 1 agent agent  8077 Nov 14 08:23 train.py\n-rw-r--r-- 1 agent agent 53565 Nov 14 08:23 uv.lock\n=== /lab/MANUAL.md ===\n# Lab0 manual\n\nWelcome to the lab. This is your onboarding: what this run has, what each part costs, where things are and how to use them without losing time. Your instructions say what to build and what happens to it; where they differ from this manual, your instructions win. `lab manual` prints it again at any time.\n\n## This run\n\n|  |  |\n|---|---|\n| Time | Exactly 12 hours from the start of the run. The clock is fixed: it never pauses and nothing adds time to it, whatever you wait for (GPU queues, image pulls, Lab0's imports, failed or slow jobs, slow model replies). Every run shares the same lab at once, so plan for waits. `lab status` shows the time left. |\n| Wallet | $85.00. It pays for H100 time and model calls made by your code. `lab status` shows what is spent, reserved and available. |\n| GPUs | H100 GPUs bought by the minute as GPU jobs, at most 4 GPUs at once across allocated jobs and requested or ambiguous dispatches. Confirmed unallocated queued jobs reserve wallet funds, not GPUs. |\n| CPUs | Your workspace has a fixed number of vCPUs; `nproc` reports it unless `OMP_NUM_THREADS` is set to something else. More processes or threads than vCPUs take turns on them and run slower. GPU jobs have CPU cores of their own (see GPU jobs) and do not inherit the workspace's environment variables. |\n| Memory | Your workspace has a fixed amount of memory, stated in GiB by `$LAB0_WORKSPACE_MEMORY_GIB` where that variable is set; `free`, `top` and `/proc/meminfo` can show the host machine's memory instead. Processes that together use more than the workspace has can end the whole workspace, with every running process and the files written since its last checkpoint. GPU jobs have memory of their own (see GPU jobs). |\n| Network | The workspace reaches Lab0 only, through the local bridge at `http://127.0.0.1:8099` (also the Unix socket `/run/lab0/bridge.sock`). `lab` and the Python client use it. |\n\n",26340,"cond and up to 0.6 on an open floor, so a direction fixed in the torso frame walks in circles. Steered with the true heading, it covered 0.9 to 1.7 units a second across the actuator gains of the final run's wider range. A follower given the true map and heading, walking through cell centres on training-family journeys, covered the shortest path at about 0.7 to 1.2 units a second: 3 to 6 reference times, of the 10 a deadline allows. It does not turn the torso, and with it the camera, on command. The adapter gives the network a yaw of zero and your direction in the torso frame, whatever the real heading. That is deliberate and not a fault: the network's actions then differ from those it gives with the true heading filled in, and the motor still walks from every heading. To go along a heading of your own, rotate it into the torso frame. The adapter has no map, absolute position, compass, goal coordinates or route; the controller supplies its own direction. You may use, modify or replace it. The `newrooms` package is installed in the final run's controller environment, so a controller can import it from there or carry its own copy. See `newrooms/assets/MOTOR-NOTICE.md` for provenance."],"d":0.5}]},{"t":35,"$":0.0185,"c":[{"n":"bash","a":"echo \"=== README.md (first 250 lines) ===\"\nhead -n 250 /workspace/repo/README.md\necho \"=== Files in newrooms and submission ===\"\nfind /workspace/repo/newrooms /workspace/repo/submission -maxdepth 3 -ls\necho \"=== MANUAL-GPU-GUIDE.md ===\"\ncat /lab/MANUAL-GPU-GUIDE.md\n","e":0,"o":["=== README.md (first 250 lines) ===\n# New Rooms\n\nGoal-conditioned visual navigation for a legged robot: OGBench's ant walks through a building it has never seen, a maze of cells and doors in the code, to the place shown in one picture, from its own camera and body sensors. This repository has the generator, renderer and simulator for the training families, the recorded corpus (`data/`), the real-time loop with local tools to run it, and a starter. The controller goes in `submission/`.\n\nTo see it run:\n\n```\npython -m newrooms.local draw --out journeys.json --count 6\npython -m newrooms.local run --submission submission --journeys journeys.json 2>&1 | grep -v NNPACK\npython -m newrooms.local view --journeys journeys.json --index 0 --out view.png\n```\n\nWhere it stands: weights trained the starter's way, on an earlier rendering, reached none of 48 training-family goals, and the bundled motor covers a known route at about 0.7 to 1.2 units a second. See \"The starter\" and \"Optional directional motor\".\n\n| Path | What it is |\n|---|---|\n| `newrooms/maze.py` | Layouts: cells, openings, door sites, the two training layout styles, door closing |\n| `newrooms/appearance.py` | Textures, landmark shapes, palettes and lighting, with the training families' layers and shapes |\n| `newrooms/families.py` | The training families and their physical ranges |\n| `newrooms/geometry.py`, `render.py`, `world.py` | Solid geometry and shortest paths, the camera, the MuJoCo world |\n| `newrooms/journeys.py` | Start and goal sampling, the time bound, the budget and the credit |\n| `newrooms/clock.py` | The real-time journey loop the final run uses, and an accelerated loop |\n| `newrooms/protocol.py`, `worker.py` | The wire format and the controller process |\n| `newrooms/local.py` | Draw training-family journeys and run a controller on them |\n| `newrooms/data.py` | Reading the corpus |\n| `submission/` | The starter controller (`controller.py`, `model.py`, `weights.pt`) |\n| `train.py` | Trains the starter from scratch on `data/` |\n\n## The controller interface\n\n`submission/controller.py` defines `Controller(root)`, where `root` is the submission directory, with `fast(observation, plan)` and an optional `slow(observation)`. An observation has exactly three fields:\n\n- `pixels`: the camera image, base64 of 64x64x3 uint8 RGB bytes in row-major order from the top-left;\n- `proprio`: 26 numbers (below);\n- `goal`: the goal image, in the same format, identical on every tick of a journey.\n\n",26458,"\n## When a job fails\n\n| You see | Because | Do |\n|---|---|---|\n| exit 124, `timed_out: true` | `--max-minutes` passed | Raise it; save checkpoints as you go and resume from them |\n| `No such file or directory` for your code | The job does not see your workspace | `lab upload` the code, `--input ID:DEST` |\n| `CUDA out of memory`, or the job killed for memory | The GPU's or the job's memory ran out | Smaller batches, gradient accumulation, one process per GPU |\n| `failure_reason: output_limit` | Its output was over the limit | Fewer checkpoints, no caches in `$LAB0_OUTPUT_DIR` |\n| `failure_reason: input_refused` | An input could not be staged as given | See Inputs that stage |\n| `ConnectionError`, `OfflineModeIsEnabled` | The command reached for the network | Give it its data and models as inputs |\n| `insufficient_funds` when you submit | Running and queued jobs hold your wallet | Lower `--max-minutes`; cancel what you do not need |\n| A job queued for long | The cluster is busy, or your run is at its GPU limit (`account_limit`) | Read `queue_reason`; cancel jobs you no longer need |"],"d":0.2}]},{"t":53.4,"$":0.0209,"c":[{"n":"bash","a":"cat /lab/MANUAL-PAPERS-AND-DATA.md\necho \"=== pyproject.toml ===\"\ncat /workspace/repo/pyproject.toml\necho \"=== which python / packages ===\"\nwhich python; which python3; python3 --version\npython3 -c \"import torch, mujoco, numpy; print('torch:', torch.__version__, 'mujoco:', mujoco.__version__, 'numpy:', numpy.__version__)\"\npip list 2>/dev/null || uv pip list 2>/dev/null || true\necho \"=== Check /opt and caches ===\"\nls -la /opt /opt/newrooms /opt/newrooms/data | head -n 40\ndu -sh /opt/newrooms/data\nfind / -name \"*cache*\" -o -name \"*huggingface*\" 2>/dev/null | head -n 40\n","e":0,"o":["# Lab0 manual: papers, data, models and software\n\nThis is the papers-and-data guide of this run's Lab0 manual; `/lab/MANUAL.md` (`lab manual`) has the rest. Where your instructions differ from it, your instructions win.\n\n## Library (arXiv)\n\nA mirror of arXiv as it stood at the end of 25 January 2026 (UTC): papers first submitted by then, each at its last version as of then, with that version's title, abstract, authors and comments. Journal references and DOIs are shown only where arXiv's record has not changed since then. Use it as you would arxiv.org:\n\n| arxiv.org | Here |\n|---|---|\n| `export.arxiv.org/api/query?...` | `http://127.0.0.1:8099/v1/arxiv/api/query?...`: the same parameters and Atom replies |\n| `arxiv.org/abs/ID` | `http://127.0.0.1:8099/v1/arxiv/abs/ID` |\n| `arxiv.org/pdf/ID` | `http://127.0.0.1:8099/v1/arxiv/pdf/ID`, and `http://127.0.0.1:8099/v1/arxiv/txt/ID`: the text extracted from the PDF |\n| `arxiv.org/list/CATEGORY/recent` | `http://127.0.0.1:8099/v1/arxiv/list/CATEGORY/recent`, or `/YYYY-MM` for one month; `?skip=N&show=N` pages |\n\n```sh\nlab papers search 'ti:\"rule learning\" AND cat:cs.LG' --max 20\nlab papers show 2106.01345\nlab papers read 2106.01345           # its text, to 2106.01345.txt (--pdf for the PDF)\nlab papers list cs.LG                # the newest submissions as of then (--month YYYY-MM)\n```\n\n- The API takes arXiv's parameters: `search_query` (fields `ti`, `au`, `abs`, `co`, `jr`, `cat`, `rn`, `id`, `all`; `AND`, `OR`, `ANDNOT`, parentheses, quoted phrases, `submittedDate:[YYYYMMDDHHMM TO YYYYMMDDHHMM]`), `id_list`, `start`, `max_results`, `sortBy` and `sortOrder`. Its entries' links lead into the mirror, so following one works.\n- The `arxiv` Python package: `arxiv.Client.query_url_format = \"http://127.0.0.1:8099/v1/arxiv/api/query?{}\"`. A result's `pdf_url` is then the mirror's, which any HTTP client fetches (in arxiv 2.x, `result.download_pdf(download_domain=\"127.0.0.1:8099\")`: its default domain is arXiv's). `feedparser` reads `http://127.0.0.1:8099/v1/arxiv/api/query?...` as it is.\n- `http://127.0.0.1:8099/v1/library/query` and `http://127.0.0.1:8099/v1/library/fulltext/ID?format=pdf` (or `txt`) answer too: the API with arxiv.org's own links.\n- Free. At most 2 requests per second (bursts of 20); each page of the mirror is one request. Queries of at most 4,096 characters, and 1,000 full-text papers per run (reading a paper again does not count; at most 64 MiB each).\n- Every request is logged.\n\n",7910,"/usr/local/lib/python3.12/ctypes/macholib/__pycache__\n/usr/local/lib/python3.12/curses/__pycache__\n/usr/local/lib/python3.12/dbm/__pycache__\n/usr/local/lib/python3.12/email/__pycache__\n/usr/local/lib/python3.12/email/mime/__pycache__\n/usr/local/lib/python3.12/encodings/__pycache__\n/usr/local/lib/python3.12/ensurepip/__pycache__\n/usr/local/lib/python3.12/html/__pycache__\n/usr/local/lib/python3.12/http/__pycache__\n/usr/local/lib/python3.12/idlelib/__pycache__\n/usr/local/lib/python3.12/importlib/__pycache__\n/usr/local/lib/python3.12/importlib/metadata/__pycache__\n/usr/local/lib/python3.12/importlib/resources/__pycache__\n/usr/local/lib/python3.12/json/__pycache__\n/usr/local/lib/python3.12/lib2to3/__pycache__\n/usr/local/lib/python3.12/lib2to3/fixes/__pycache__\n/usr/local/lib/python3.12/lib2to3/pgen2/__pycache__\n/usr/local/lib/python3.12/linecache.py\n/usr/local/lib/python3.12/logging/__pycache__\n/usr/local/lib/python3.12/multiprocessing/__pycache__\n/usr/local/lib/python3.12/multiprocessing/dummy/__pycache__\n/usr/local/lib/python3.12/pydoc_data/__pycache__\n/usr/local/lib/python3.12/re/__pycache__\n/usr/local/lib/python3.12/site-packages/pip/__pycache__"],"d":7}]},{"t":74.6,"$":0.0136,"c":[{"n":"bash","a":"cat /lab/MANUAL-GPU-JOBS.md\necho \"=== train.py ===\"\ncat /workspace/repo/train.py\necho \"=== submission/controller.py ===\"\ncat /workspace/repo/submission/controller.py\necho \"=== submission/model.py ===\"\ncat /workspace/repo/submission/model.py\nls -la /home/agent/.cache/huggingface 2>/dev/null || true\n","e":0,"o":["# Lab0 manual: GPU jobs\n\nThis is the GPU jobs part of this run's Lab0 manual; `/lab/MANUAL.md` (`lab manual`) has the rest. Where your instructions differ from it, your instructions win.\n\n## What GPU time costs\n\n- GPU time is charged per GPU for each started minute, from when the job's container starts (its `--input` artifacts are staged after that, inside the job's time) until its command exits or it is stopped, and never for more than `max_minutes`. Time spent queued is free, and so is the time spent collecting a finished job's outputs. A job stopped after 20 of its 60 minutes is charged 20 minutes.\n- Every job whose container started is charged for the time it ran, however it ended: your command's own exit, a cancel, its time limit, or a fault of the infrastructure (a lost machine or GPU, a failure of Lab0's job wrapper: `failure_class: provider`). Only a job that never started (a failed image pull or container start) costs nothing. Lab0 runs a batch job that failed for the infrastructure again once by itself, billed as any job: `lab gpu show` names the new job (`retried_as`), so do not submit it again. A job whose borrowed GPUs Lab0's scheduler takes back (see GPU jobs) is charged for the time it ran too; `lab gpu resubmit JOB_ID` runs it again (a batch job resuming from its partial output).\n- A job whose `--input` artifacts cannot be staged as given (an archive that does not unpack whole: links, special files or paths outside it; or one too large to unpack within the job's time) fails before its command as your job's own failure (`failure_reason: input_refused`, `failure_error` says why): charged for the time it held its GPUs, and not run again. Upload directories with `lab upload DIR`, and plain archives of regular files and directories.\n- At the deadline Lab0 stops every running job.\n- Your clock is fixed: nothing is added to your deadline. The time a job waits in the GPU queue or while its machine pulls its image (`queue_reason: pulling the image`), a failed job's running time and any wait for Lab0 (a held dispatch, a run again waiting for the output of the job before it, an output waiting for Lab0's import capacity) all come out of your research time. Queueing, pulls and those waits are not charged.\n\n## GPU jobs\n\nA GPU job runs one command on H100 GPUs on one host, in one of this run's images. Submit it from the workspace:\n\n```sh\nlab upload /workspace/repo            # prints an artifact id\n",24580,"    def __init__(self, width=256):\n        super().__init__()\n        self.net = nn.Sequential(nn.Conv2d(3, 32, 4, 2), nn.ReLU(), nn.Conv2d(32, 64, 4, 2), nn.ReLU(),\n                                 nn.Conv2d(64, 64, 3, 2), nn.ReLU(), nn.Flatten(), nn.Linear(64 * 6 * 6, width), nn.ReLU())\n\n    def forward(self, pixels):\n        return self.net(pixels.permute(0, 3, 1, 2).float() / 255.0)\n\n\nclass Policy(nn.Module):\n    def __init__(self, width=256, hidden=512):\n        super().__init__()\n        self.encoder = Encoder(width)\n        self.head = nn.Sequential(nn.Linear(2 * width + 26, hidden), nn.ReLU(), nn.Linear(hidden, hidden), nn.ReLU(),\n                                  nn.Linear(hidden, 8), nn.Tanh())\n        self.register_buffer(\"mean\", torch.zeros(26))\n        self.register_buffer(\"std\", torch.ones(26))\n\n    def forward(self, pixels, goal, proprio):\n        body = (proprio - self.mean) / self.std\n        return self.head(torch.cat((self.encoder(pixels), self.encoder(goal), body), -1))\ntotal 2\ndrwxr-xr-x 4 root root 45 Nov 14 08:23 .\ndrwxr-xr-x 3 root root 10 Nov 14 08:23 ..\ndrwxrwxrwt 2 root root  6 Nov 14 08:23 datasets\ndrwxrwxrwt 3 root root 28 Nov 14 08:23 hub"],"d":0.2}]},{"t":88.5,"$":0.02,"c":[{"n":"bash","a":"for f in maze.py appearance.py families.py geometry.py render.py world.py journeys.py; do\n    echo \"================ newrooms/$f ================\"\n    cat /workspace/repo/newrooms/$f\ndone\n","e":0,"o":["================ newrooms/maze.py ================\n\"\"\"Maze layouts: a grid of 4-unit cells joined by openings, some of which hold doors.\n\nA layout is generated deterministically from its parameters and seed (`generate`). Cell (r, c) spans\nx in [4c, 4c + 4] and y in [4r, 4r + 4]; walls are 0.4 units thick, centred on the cell boundaries, and 2 units\ntall. An opening between two cells is 3.6 units wide; a door site narrows it to 2.8 units with a frame post on each\nside, and a closed door fills the rest.\n\nThe training layouts have two styles: `corridors` (a depth-first spanning tree: long winding corridors) and\n`branching` (a randomized Kruskal spanning tree: many short dead ends). Test layouts use styles of the team's\nthat this repository does not hold. Every style then opens a fraction `loops` of the remaining internal walls. Door\nsites are a fraction `doors` of the openings that lie on a loop; at a journey's start each door is closed\nindependently with probability 1/2, redrawn until every cell stays reachable, so a closed door forces a detour and\nnever cuts the maze in two.\n\"\"\"\nfrom __future__ import annotations\n\nimport hashlib\nimport json\nfrom collections import deque\n\nimport numpy as np\n\nCELL = 4.0\nWALL = 0.4\nHEIGHT = 2.0\n\n\ndef mix(*parts) -> int:\n    \"\"\"A 63-bit seed from any JSON-serializable parts.\"\"\"\n    digest = hashlib.sha256(json.dumps(parts, sort_keys=True, separators=(\",\", \":\")).encode()).digest()\n    return int.from_bytes(digest[:8], \"big\") >> 1\n\n\ndef edge(a, b):\n    \"\"\"The canonical key of the opening between adjacent cells a and b: (r, c, 0) joins (r, c) and (r, c + 1);\n    (r, c, 1) joins (r, c) and (r + 1, c).\"\"\"\n    (r0, c0), (r1, c1) = sorted((tuple(a), tuple(b)))\n    if r0 == r1 and c1 == c0 + 1:\n        return (r0, c0, 0)\n    if c0 == c1 and r1 == r0 + 1:\n        return (r0, c0, 1)\n    raise ValueError(\"cells are not adjacent\")\n\n\ndef neighbours(rows, cols, cell):\n    r, c = cell\n    for dr, dc in ((0, 1), (1, 0), (0, -1), (-1, 0)):\n        if 0 <= r + dr < rows and 0 <= c + dc < cols:\n            yield (r + dr, c + dc)\n\n\nclass Layout:\n    \"\"\"Cells, openings (a set of edge keys) and door sites (a subset of the openings).\"\"\"\n\n    def __init__(self, rows, cols, openings, doors, rooms=()):\n        self.rows, self.cols = rows, cols\n        self.openings = frozenset(openings)\n        self.doors = tuple(sorted(doors))\n        self.rooms = tuple(rooms)\n        if not set(self.doors) <= self.openings:\n",26391,"            options = [cell for cell, d in reach.items() if cells[0] <= d <= cells[1]]\n        else:\n            low = BINS[min(bins)][0] / CELL * .7\n            high = BINS[max(bins)][1] / CELL * 1.6\n            options = [cell for cell, d in reach.items() if low <= d <= high]\n        if not options:\n            continue\n        goal_cell = options[int(rng.integers(len(options)))]\n        start, goal = cell_point(start_cell, rng), cell_point(goal_cell, rng)\n        if bins is not None and geometry.visible(start, goal)[0, 0]:\n            continue\n        geodesic = geometry.geodesic(start, goal)\n        index = bin_of(geodesic)\n        if bins is not None and index not in bins:\n            continue\n        t_bound = bound(geodesic)\n        return {\"start\": [round(start[0], 4), round(start[1], 4), round(float(rng.uniform(-math.pi, math.pi)), 6)],\n                \"goal\": [round(goal[0], 4), round(goal[1], 4)], \"goal_yaw\": goal_yaw(camera, goal, rng),\n                \"geodesic\": round(geodesic, 4), \"bin\": index, \"t_bound\": round(t_bound, 4),\n                \"budget\": round(budget(t_bound), 2), \"cells\": reach[goal_cell], \"goal_camera_height\": GOAL_CAMERA_HEIGHT}\n    return None"],"d":0.5}]},{"t":96,"$":0.0247,"c":[{"n":"bash","a":"echo \"=== appearance.py (tail) ===\"\ntail -n 140 /workspace/repo/newrooms/appearance.py\nfor f in families.py geometry.py render.py locomotion.py data.py protocol.py worker.py; do\n    echo \"================ newrooms/$f ================\"\n    cat /workspace/repo/newrooms/$f\ndone\n","e":0,"o":["=== appearance.py (tail) ===\n        raise ValueError(f\"unknown pattern layer {spec['layer']!r}\")\n    return layer(spec, shape, rng)\n\n\ndef _shape_mask(name, shape, centre, size, rng):\n    u, v = _uv(shape)\n    h, w = shape\n    x, y = (u - centre[0]) * w / h / size, (v - centre[1]) / size     # aspect-corrected, unit = size\n    mask = SHAPES.get(name)\n    if mask is None:\n        raise ValueError(f\"unknown landmark shape {name!r}\")\n    return mask(x, y, np.sqrt(x * x + y * y), np.arctan2(y, x))\n\n\ndef _uniform(rng, bounds):\n    low, high = bounds\n    return float(rng.uniform(low, high))\n\n\ndef _colour(rng, palette):\n    hue = _uniform(rng, palette[\"hue\"]) % 1.0\n    return [round(x, 4) for x in colorsys.hsv_to_rgb(hue, _uniform(rng, palette[\"saturation\"]),\n                                                       _uniform(rng, palette[\"value\"]))]\n\n\ndef _draw_layer(rng, options):\n    \"\"\"A concrete layer from a list of layer ranges: each value is drawn uniformly in its [low, high].\"\"\"\n    spec = options[int(rng.integers(len(options)))]\n    out = {\"layer\": spec[\"layer\"]}\n    for key, value in spec.items():\n        if key == \"layer\":\n            continue\n        if isinstance(value, list) and value and isinstance(value[0], list):\n            out[key] = [int(rng.integers(lo, hi + 1)) if isinstance(lo, int) else round(_uniform(rng, (lo, hi)), 4)\n                        for lo, hi in value]\n        elif isinstance(value, list):\n            lo, hi = value\n            out[key] = int(rng.integers(lo, hi + 1)) if isinstance(lo, int) else round(_uniform(rng, (lo, hi)), 4)\n        else:\n            out[key] = value\n    return out\n\n\ndef _surface(rng, family):\n    return {\"pattern\": _draw_layer(rng, family[\"patterns\"]), \"colours\": [_colour(rng, family[\"palette\"]),\n            _colour(rng, family[\"palette\"])], \"grain\": round(_uniform(rng, family[\"grain\"]), 4)}\n\n\ndef draw(family: dict, seed: int) -> dict:\n    \"\"\"One maze's concrete appearance from a family.\"\"\"\n    rng = np.random.default_rng(mix(\"appearance\", family.get(\"name\", \"\"), seed))\n    walls = family[\"wall\"]\n    variants = int(rng.integers(walls[\"variants\"][0], walls[\"variants\"][1] + 1))\n    light = family[\"light\"]\n    marks = family[\"landmarks\"]\n    return {\n        \"family\": family.get(\"name\", \"\"), \"seed\": seed,\n        \"walls\": [_surface(rng, walls) for _ in range(variants)],\n        \"floor\": {**_surface(rng, family[\"floor\"]), \"period\": round(_uniform(rng, family[\"floor\"][\"period\"]), 4)},\n",26407,"    output = sys.stdout\n    sys.stdout = sys.stderr\n    spec.loader.exec_module(module)\n    controller = module.Controller(root)\n    # Drain only observation-free setup before reporting readiness. Otherwise\n    # the first callback can inherit pending CUDA context/weight initialization.\n    # Every actual fast/slow callback still synchronizes before its timed reply.\n    if synchronize is not None:\n        synchronize()\n    output.write('{\"ready\":true}\\n')\n    output.flush()\n    while line := sys.stdin.buffer.readline(REQUEST_BYTES + 1):\n        if len(line) > REQUEST_BYTES:\n            raise ValueError(\"request too large\")\n        request = json.loads(line)\n        if request[\"method\"] == \"fast\":\n            answer = controller.fast(request[\"observation\"], request[\"plan\"])\n        elif request[\"method\"] == \"slow\":\n            answer = controller.slow(request[\"observation\"])\n        else:\n            raise ValueError(\"unknown callback\")\n        if synchronize is not None:\n            synchronize()\n        output.write(canonical({\"id\": request[\"id\"], \"value\": answer}).decode() + \"\\n\")\n        output.flush()\n\n\nif __name__ == \"__main__\":\n    main()"],"d":0.2}]},{"t":102.7,"$":0.0247,"c":[{"n":"bash","a":"for f in geometry.py render.py clock.py sandbox.py; do\n    echo \"================ newrooms/$f ================\"\n    cat /workspace/repo/newrooms/$f\ndone\n","e":0,"o":["================ newrooms/geometry.py ================\n\"\"\"The solid geometry of a layout with a journey's closed doors: a 0.4-unit occupancy grid, wall boxes, and the\nshortest path for a point.\n\nGrid index i covers x in [0.4 i - 0.2, 0.4 i + 0.2); solid sub-cells lie only on the cell boundaries (i or j a\nmultiple of 10). Each solid sub-cell keeps a material for each of its four faces (-x, +x, -y, +y).\n\"\"\"\nfrom __future__ import annotations\n\nimport numpy as np\n\nfrom .maze import CELL, WALL, Layout, edge\n\nSUB = 10                     # sub-cells per cell\nRES = CELL / SUB             # 0.4 units\nFREE, SOLID, FRAME, DOOR = 0, 1, 2, 3\nFACES = 4                    # -x, +x, -y, +y\n\n\nclass Geometry:\n    def __init__(self, layout: Layout, closed=(), materials=None):\n        \"\"\"`materials(kind, cell, side)` names each face's material id: kind is \"wall\", \"frame\", \"door\" or\n        \"corner\"; side is \"E\", \"W\", \"N\", \"S\" for a wall face seen from `cell`. The default gives every face 0.\"\"\"\n        self.layout, self.closed = layout, frozenset(map(tuple, closed))\n        rows, cols = layout.rows, layout.cols\n        self.shape = (SUB * rows + 1, SUB * cols + 1)\n        solid = np.zeros(self.shape, np.int8)\n        faces = np.zeros(self.shape + (FACES,), np.int16)\n        material = materials or (lambda kind, cell, side: 0)\n\n        def segment(line_index, run, vertical):\n            \"\"\"Boundary between cells across a line: for vertical lines (x = 4 line_index) the run is a cell row.\"\"\"\n            if vertical:\n                a, b = (run, line_index - 1), (run, line_index)\n                outside = line_index in (0, cols)\n            else:\n                a, b = (line_index - 1, run), (line_index, run)\n                outside = line_index in (0, rows)\n            key = None if outside else edge(a, b)\n            if outside or key not in layout.openings:\n                return \"wall\", a, b\n            if key in layout.doors:\n                return (\"closed\" if key in self.closed else \"door\"), a, b\n            return \"open\", a, b\n\n        def put(j, i, code, mats):\n            solid[j, i] = code\n            faces[j, i] = mats\n\n        def wall_faces(a, b, vertical):\n            inside = lambda cell: 0 <= cell[0] < rows and 0 <= cell[1] < cols  # noqa: E731\n            if vertical:   # -x face is seen from a (west cell), +x from b\n                return [material(\"wall\", a, \"E\") if inside(a) else 0, material(\"wall\", b, \"W\") if inside(b) else 0,\n",26399,"    import numpy  # noqa: F401\n\n    restore_thread_affinity(inherited_cpus)\n    install_absolute_limit()\n    install_thread_only_filter()\n    install_affinity_filter()\n    return core_probe()\n\n\ndef main(limits=None) -> None:\n    try:\n        probe = initialize(limits)\n    except Exception:\n        traceback.print_exc()\n        print('{\"infrastructure\":\"trusted runtime boundary initialization failed\"}', flush=True)\n        return\n    # This first frame is written before the submission is imported, so later output of the submission cannot\n    # forge an earlier initialization failure.\n    print(json.dumps({\"runtime_initialized\": True, \"core_probe\": probe}, sort_keys=True, separators=(\",\", \":\")),\n          flush=True)\n    worker, submission = sys.argv[1:]\n    sys.argv = [worker, submission]\n    runpy.run_path(worker, run_name=\"__main__\")\n\n\nif __name__ == \"__main__\":\n    # Locally (clock.LocalController) the user's thread limit is left as it is: RLIMIT_NPROC counts every process and\n    # thread of the user, and in evaluation that user runs nothing but the controller.\n    main({kind: value for kind, value in LIMITS.items() if kind != resource.RLIMIT_NPROC})"],"d":0.2}]},{"t":120.3,"$":0.0253,"c":[{"n":"bash","a":"echo \"=== render.py ===\"\ncat /workspace/repo/newrooms/render.py\necho \"=== clock.py (first 220 lines) ===\"\nhead -n 220 /workspace/repo/newrooms/clock.py\necho \"=== local.py ===\"\ncat /workspace/repo/newrooms/local.py\necho \"=== MOTOR-NOTICE.md & ant.xml ===\"\ncat /workspace/repo/newrooms/assets/MOTOR-NOTICE.md\ncat /workspace/repo/newrooms/assets/ant.xml\n","e":0,"o":["=== render.py ===\n\"\"\"The robot's camera: a level, forward-facing pinhole view, ray-cast on the CPU.\n\nThe camera sits CAMERA_RISE above the torso's centre, turns with the torso's heading and does not pitch or roll. It\nhas a 90-degree horizontal and vertical field of view and renders 64x64 RGB. The robot's own body is not drawn.\nWalls, frames and doors are vertical; the floor is at height 0 and the ceiling at the wall height. Light is an\nambient term plus a sun that raises every wall face alike (the same for all four directions a face can point, so the\nshading says nothing about which way the camera looks), a colour tint, and exponential fog towards the fog colour.\nFloor and ceiling tiles are laid afresh in every cell (`Materials`).\n\"\"\"\nfrom __future__ import annotations\n\nimport numpy as np\n\nfrom .appearance import FLOOR_TEX, WALL_TEX, Materials\nfrom .geometry import RES, Geometry\nfrom .maze import CELL, HEIGHT\n\nSIZE = 64\nFOCAL = SIZE / 2          # 90 degrees across the image\nCAMERA_RISE = 0.25\nMAX_DEPTH = 80.0\nCROSSINGS = 340           # grid lines a column's ray may cross (170 per axis: 68 units along one axis)\n\n_OFFSETS = (np.arange(SIZE) + .5 - SIZE / 2) / FOCAL        # column offsets, left to right\n_SLOPES = (SIZE / 2 - (np.arange(SIZE) + .5)) / FOCAL       # row slopes, top to bottom\n\n\nclass Camera:\n    def __init__(self, geometry: Geometry, materials: Materials):\n        self.geometry, self.materials = geometry, materials\n        light = materials.light\n        elevation = np.radians(light[\"elevation\"])\n        sun = np.radians(light[\"azimuth\"])\n        # A face pointing along one axis would catch max(0, n . sun); every face gets the mean over the four directions.\n        self.wall_light = light[\"ambient\"] + light[\"sun\"] * np.cos(elevation) * (abs(np.cos(sun)) + abs(np.sin(sun))) / 4\n        self.floor_light = light[\"ambient\"] + light[\"sun\"] * np.sin(elevation)\n        self.ceiling_light = light[\"ambient\"] * .8\n\n    def render(self, x, y, z, yaw):\n        \"\"\"uint8 [64, 64, 3] seen from (x, y, z) facing `yaw` radians anticlockwise from +x.\"\"\"\n        m = self.materials\n        forward = np.array([np.cos(yaw), np.sin(yaw)])\n        right = np.array([np.sin(yaw), -np.cos(yaw)])\n        rays = forward[None] + _OFFSETS[:, None] * right[None]                    # [W, 2], unit forward component\n        depth, kind, _, along = self._cast(np.array([x, y]), rays)\n        image = np.empty((SIZE, SIZE, 3), np.float32)\n",26398,"                    <geom name=\"rightback_leg_geom\" type=\"capsule\" size=\"0.08\" fromto=\"0.0 0.0 0.0 0.2 -0.2 0.0\"/>\n                    <body pos=\"0.2 -0.2 0\">\n                        <joint name=\"ankle_4\" type=\"hinge\" pos=\"0.0 0.0 0.0\" axis=\"1 1 0\" range=\"30 70\"/>\n                        <geom name=\"fourth_ankle_geom\" type=\"capsule\" size=\"0.08\" fromto=\"0.0 0.0 0.0 0.4 -0.4 0.0\"/>\n                    </body>\n                </body>\n            </body>\n        </body>\n    </worldbody>\n\n    <actuator>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"hip_4\" gear=\"30\"/>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"ankle_4\" gear=\"30\"/>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"hip_1\" gear=\"30\"/>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"ankle_1\" gear=\"30\"/>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"hip_2\" gear=\"30\"/>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"ankle_2\" gear=\"30\"/>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"hip_3\" gear=\"30\"/>\n        <motor ctrllimited=\"true\" ctrlrange=\"-1.0 1.0\" joint=\"ankle_3\" gear=\"30\"/>\n    </actuator>\n</mujoco>"],"d":0.2}]},{"t":132.6,"$":0.0268,"c":[{"n":"bash","a":"head -n 180 /workspace/repo/newrooms/local.py\necho \"=== git log ===\"\ngit -C /workspace/repo log -n 5\necho \"=== lab status ===\"\nlab status\necho \"=== check HF datasets mirror ===\"\nlab datasets search \"\" 2>&1 | head -n 30 || true\n","e":0,"o":["\"\"\"Draw training-family journeys and run a submission on them locally.\n\n    python -m newrooms.local draw --out journeys.json [--count 30] [--seed 0] [--bins 0 1 2]\n    python -m newrooms.local run --submission submission --journeys journeys.json [--realtime [--unsandboxed]]\n                                 [--out results.json]\n    python -m newrooms.local view --journeys journeys.json --index 0 --out view.png\n\n`--journeys` takes a list of journeys or {\"cases\": [...]}.\n\n`draw` samples training-family journeys (`newrooms.families.sample_maze`, `newrooms.journeys.sample`), with their\nbounds and budgets; the final run's layouts use other styles (the README, \"The final run\"). `run` plays each journey:\naccelerated by default (in this process, every reply on time), or with `--realtime` through the final run's real-time\nloop and a child process. That child runs inside the controller's runtime boundary (`newrooms.sandbox`,\n`clock.LocalController`): `python -I`, the final run's cleared environment, two pinned CPUs, the file-size,\nfile-descriptor and address-space limits and the system-call filters, with its error output printed here. It needs\nLinux x86_64; `--unsandboxed` runs a plain child process instead. `run` prints each journey's credit and speed term and\nthe mean credit over bins.\n\n`--realtime` also checks timing with a margin of at least 10% against the final run's limits:\n- it charges each tick's drawing at max(the time it took here, HOST_RENDER_P99_MS), so the controller's share of\n  the 20 ms window is no larger than on the final run's host, and reports the measured drawing as `observe_ms`;\n- it reports `callback_ms`, each fast reply's arrival after its tick's start (median, 99th percentile, maximum),\n  and flags replies after REPLY_FLAG_MS (18 ms, against the 20 ms deadline);\n- it reports `cpu`, the controller process's peak use of two cores over any 250 ms, flagged at CORE_FLAG_SHARE (81%,\n  against the final run's 90%), and its peak cores over any 40 ms, flagged above BURST_FLAG_CORES (2.25, against the\n  final run's 2.5). It needs /proc, as in the research image.\n\nA scheduling miss (newrooms.clock.SchedulingMiss) is handled as the final run handles one journey's: the journey runs\nagain with a new controller process, at most HOST_TRIES tries in all, each miss listed under `host_misses`; but a\nsecond miss on the journey while the controller used at least SATURATION_SHARE of its two cores over the last 250 ms,\n",7648,"      \"served_through\": \"2026-01-25\",\n      \"withheld\": false\n    },\n    \"datasets\": {\n      \"offered\": true\n    },\n    \"validations\": null,\n    \"deliverables\": {\n      \"max_bytes\": 2000000000,\n      \"paths\": [\n        \"submission\"\n      ]\n    }\n  },\n  \"selection\": {\n    \"submission_id\": null,\n    \"selected_at\": null,\n    \"selected_at_iso\": null,\n    \"frozen\": false\n  },\n  \"features\": [\n    \"background-submit\"\n  ]\n}\n=== check HF datasets mirror ===\n{\n  \"total\": 113,\n  \"offset\": 0,\n  \"results\": [\n    {\n      \"repo\": \"Bertievidgen/SimpleSafetyTests\",\n      \"revision\": \"98223c5d8c4059c8f4d8fe2fec8720ee8a20d3c5\",\n      \"size_bytes\": 15544,\n      \"files\": 3,\n      \"description\": \"\",\n      \"license\": \"cc-by-2.0\",\n      \"tags\": [\n        \"task_categories:text-generation\",\n        \"language:en\",\n        \"license:cc-by-2.0\",\n        \"size_categories:n<1K\",\n        \"format:csv\",\n        \"arxiv:2311.08370\"\n      ]\n    },\n    {\n      \"repo\": \"ChilleD/SVAMP\",\n      \"revision\": \"5e0bf1e5e7c0e9c4bc39180d224f41f3f801b7ef\",\n      \"size_bytes\": 509138,\n      \"files\": 6,\n      \"description\": \"\",\n      \"license\": \"mit\",\n      \"tags\": [\n        \"task_categories:text-generation\",\n        \"language:en\","],"d":1.1}]},{"t":143.7,"$":0.0174,"c":[{"n":"bash","a":"sed -n '180,290p' /workspace/repo/newrooms/local.py\necho \"=== Inspect maze-0000 ===\"\npython3 -c '\nimport json, numpy as np\nfrom newrooms import data\narrays, rec = data.shard(\"data\", 0)\nprint(\"Record keys:\", list(rec.keys()))\nprint(\"Maze keys:\", list(rec[\"maze\"].keys()))\nprint(\"Episodes count:\", len(rec[\"episodes\"]))\nprint(\"Ep 0:\", rec[\"episodes\"][0])\nprint(\"Ep 5:\", rec[\"episodes\"][5])\nfor k, v in arrays.items():\n    print(f\"  {k}: shape={v.shape}, dtype={v.dtype}\")\n'\n","e":0,"o":["    def _window(self):\n        \"\"\"The last CORE_WINDOW_SECONDS read now (or since the first sample, if that is more recent): its samples,\n        ending with now's; None without /proc. Timed after the read, as every sample is.\"\"\"\n        used, now = self.read(), self.clock()\n        samples = list(self.samples)\n        if used is None or not samples:\n            return None\n        older = [sample for sample in samples if sample[0] <= now - CORE_WINDOW_SECONDS]\n        start = older[-1] if older else samples[0]\n        if now <= start[0]:\n            return None\n        return [sample for sample in samples if start[0] <= sample[0] < now] + [(now, used)]\n\n    def recent(self):\n        \"\"\"The share of the two cores used over the last CORE_WINDOW_SECONDS (or since the first sample, if that is\n        more recent), read now, as the final run reads it at a scheduling miss; None without /proc.\"\"\"\n        window = self._window()\n        if window is None:\n            return None\n        (then, before), (now, used) = window[0], window[-1]\n        return max(0.0, used - before) / (now - then) / CONTROLLER_CORES\n\n    def recent_burst(self):\n        \"\"\"The most cores used over any BURST_SECONDS or more of the same window, as the final run reads it at a\n        scheduling miss; None without /proc or without such a slice.\"\"\"\n        window = self._window()\n        return None if window is None else burst(window, every_pair=True)\n\n    def peak(self):\n        \"\"\"{\"peak_cores\", \"peak_share\", \"flagged\", \"peak_burst_cores\", \"burst_flagged\"} over every full window, or\n        None without one.\"\"\"\n        samples, best, start = list(self.samples), None, 0\n        for now, used in samples:\n            while start + 1 < len(samples) and samples[start + 1][0] <= now - CORE_WINDOW_SECONDS:\n                start += 1\n            then, before = samples[start]\n            if now - then >= CORE_WINDOW_SECONDS:\n                cores = max(0.0, used - before) / (now - then)\n                best = cores if best is None else max(best, cores)\n        if best is None:\n            return None\n        share, most = best / CONTROLLER_CORES, burst(samples)\n        return {\"peak_cores\": round(best, 3), \"peak_share\": round(share, 3), \"flagged\": share >= CORE_FLAG_SHARE,\n                \"peak_burst_cores\": None if most is None else round(most, 3),\n                \"burst_flagged\": most is not None and most > BURST_FLAG_CORES}\n\n\ndef burst(samples, *, every_pair=False):\n",3289,"                break\n        else:\n            raise RuntimeError(f\"could not draw requested journey {number + 1} in distance bin {b}; \"\n                               \"no partial set of journeys was returned\")\n=== Inspect maze-0000 ===\nRecord keys: ['bytes', 'episodes', 'index', 'layout_sha256', 'maze', 'sha256', 'shard', 'ticks']\nMaze keys: ['appearance', 'layout', 'physics']\nEpisodes count: 17\nEp 0: {'closed': [[2, 6, 0], [3, 6, 1], [7, 3, 0], [9, 8, 1]], 'flipped': False, 'goal_index': None, 'kind': 'explore', 'seed': 0, 'start': [1.4351, 2.1127, 0.7047], 'ticks': 1000}\nEp 5: {'closed': [[0, 6, 0], [0, 13, 1], [2, 6, 0], [3, 11, 1], [7, 1, 1], [9, 8, 1], [11, 10, 0]], 'flipped': False, 'goal': [42.1259, 5.4705], 'goal_index': 0, 'goal_yaw': 0.043384, 'kind': 'stitch', 'reached_tick': 319, 'seed': 0, 'start': [29.5885, 10.791, 0.2512], 'ticks': 400}\n  pixels: shape=(9463, 64, 64, 3), dtype=uint8\n  proprio: shape=(9463, 26), dtype=float32\n  action: shape=(9463, 8), dtype=float32\n  qpos: shape=(9463, 15), dtype=float32\n  qvel: shape=(9463, 14), dtype=float32\n  episode: shape=(9463,), dtype=int16\n  tick: shape=(9463,), dtype=int16\n  goals: shape=(12, 64, 64, 3), dtype=uint8"],"d":1.6}]},{"t":240.8,"$":0.0888,"c":[{"n":"list_submissions","a":{},"o":"{\"versions\": [], \"selection\": null, \"handins\": {\"handed_in\": {}, \"uploading\": {}, \"failures\": {}, \"retries\": {}, \"transfers\": {}, \"final\": null}}","d":0.3}]},{"t":255.6,"$":0.0254,"c":[{"n":"bash","a":"mkdir -p /workspace/work\ncat /workspace/repo/.gitignore 2>/dev/null || true\ntime python3 -m newrooms.local draw --out /workspace/work/j6.json --count 6 --seed 7\ntime python3 -m newrooms.local run --submission /workspace/repo/submission --journeys /workspace/work/j6.json 2>&1 | grep -v NNPACK\n","e":0,"o":"\nreal\t0m3.021s\nuser\t0m4.470s\nsys\t0m0.030s\n{\"id\": \"local-0\", \"bin\": 0, \"success\": false, \"steps\": 1158, \"t_bound\": 5.7878, \"budget\": 57.9, \"speed\": 0.0, \"credit\": 0.0}\n{\"id\": \"local-1\", \"bin\": 1, \"success\": false, \"steps\": 2054, \"t_bound\": 10.2697, \"budget\": 102.7, \"speed\": 0.0, \"credit\": 0.0}\n{\"id\": \"local-2\", \"bin\": 2, \"success\": false, \"steps\": 4138, \"t_bound\": 20.6876, \"budget\": 206.9, \"speed\": 0.0, \"credit\": 0.0}\n{\"id\": \"local-3\", \"bin\": 0, \"success\": false, \"steps\": 1712, \"t_bound\": 8.5584, \"budget\": 85.6, \"speed\": 0.0, \"credit\": 0.0}\n{\"id\": \"local-4\", \"bin\": 1, \"success\": false, \"steps\": 1913, \"t_bound\": 9.5641, \"budget\": 95.65, \"speed\": 0.0, \"credit\": 0.0}\n{\"id\": \"local-5\", \"bin\": 2, \"success\": false, \"steps\": 4447, \"t_bound\": 22.2306, \"budget\": 222.35, \"speed\": 0.0, \"credit\": 0.0}\n{\"by_bin\": {\"0\": 0.0, \"1\": 0.0, \"2\": 0.0}, \"raw_credit\": 0.0}\n\nreal\t1m13.261s\nuser\t1m12.620s\nsys\t0m0.380s","d":76.8}]},{"t":347.9,"$":0.0193,"c":[{"n":"bash","a":"python3 -c '\nimport json, numpy as np\nfrom newrooms.world import World\nfrom newrooms.local import png\n\ncases = json.loads(open(\"/workspace/work/j6.json\").read())\nrows = []\nfor c in cases:\n    w = World(c)\n    obs = w.pixels()\n    goal = np.frombuffer(w.goal_image, np.uint8).reshape(64, 64, 3)\n    sep = np.full((64, 4, 3), 255, np.uint8)\n    rows.append(np.concatenate([obs, sep, goal], axis=1))\n    rows.append(np.full((4, rows[-1].shape[1], 3), 255, np.uint8))\ngrid = np.concatenate(rows[:-1], axis=0)\n# Upscale 3x nearest neighbor so it is crisp to view\ngrid = np.repeat(np.repeat(grid, 3, axis=0), 3, axis=1)\nopen(\"/workspace/work/j6_views.png\", \"wb\").write(png(grid))\nprint(\"Saved j6_views.png\", grid.shape)\n'\n","e":0,"o":"Saved j6_views.png (1212, 396, 3)","d":1.5}]},{"t":357.2,"$":0.0147,"c":[{"n":"view_image","a":{"path":"/workspace/work/j6_views.png","query":"Inspect the 6 start camera views (left) and goal images (right) to understand textures, lighting, fog, doors, frames, corner posts, ceiling/wall/floor edges, and landmarks."},"o":"Attached image /workspace/work/j6_views.png (83415 bytes).","d":2.5}]},{"t":359.6,"k":"image","p":"/workspace/work/j6_views.png. Inspect the 6 start camera views (left) and goal images (right) to understand textures, lighting, fog, doors, frames, corner posts, ceiling/wall/floor edges, and landmarks"},{"t":604.3,"$":0.1804,"c":[{"n":"bash","a":"python3 -c '\nimport numpy as np\nfrom newrooms import data\nfrom newrooms.world import rotation, heading\n\narrays, rec = data.shard(\"data\", 0)\nqpos = arrays[\"qpos\"]\nproprio = arrays[\"proprio\"]\nep = arrays[\"episode\"]\n\n# Test dead-reckoning integration from proprio ONLY vs ground truth qpos!\n# Recall:\n# proprio[0] = z\n# proprio[1:4] = R^T @ [0, 0, -1]  (gravity in body frame)\n# proprio[12:15] = R^T @ v_world   (linear vel in body frame)\n# proprio[15:18] = omega_body      (angular vel in body frame)\n\ndef exp_so3(w):\n    theta = np.linalg.norm(w)\n    if theta < 1e-12:\n        return np.eye(3) + np.array([[0, -w[2], w[1]], [w[2], 0, -w[0]], [-w[1], w[0], 0]])\n    k = w / theta\n    K = np.array([[0, -k[2], k[1]], [k[2], 0, -k[0]], [-k[1], k[0], 0]])\n    return np.eye(3) + np.sin(theta) * K + (1 - np.cos(theta)) * (K @ K)\n\ndef align_gravity(R, g_body):\n    # g_world_est = R @ g_body should equal [0, 0, -1]\n    # Minimal rotation in world frame taking (R @ g_body) to [0, 0, -1] preserves yaw closely!\n    u = R @ (g_body / np.linalg.norm(g_body))\n    target = np.array([0.0, 0.0, -1.0])\n    cross = np.cross(u, target)\n    dot = np.clip(np.dot(u, target), -1.0, 1.0)\n    if dot < -0.9999:\n        return R\n    s = np.sqrt((1 + dot) * 2)\n    q = np.array([s / 2, cross[0] / s, cross[1] / s, cross[2] / s])\n    return rotation(q) @ R\n\ndt = 0.05\nerrs_1s, errs_5s, errs_20s = [], [], []\nyaw_1s, yaw_5s, yaw_20s = [], [], []\n\nfor e_id in range(len(rec[\"episodes\"])):\n    idx = np.flatnonzero(ep == e_id)\n    if len(idx) < 50: continue\n    R = rotation(qpos[idx[0], 3:7])\n    R = align_gravity(np.eye(3), proprio[idx[0], 1:4])\n    # Set true initial yaw just to compare relative trajectory in world frame\n    yaw0_true = heading(qpos[idx[0], 3:7])\n    yaw0_est = np.arctan2(R[1, 0], R[0, 0])\n    dy0 = yaw0_true - yaw0_est\n    Rz = np.array([[np.cos(dy0), -np.sin(dy0), 0], [np.sin(dy0), np.cos(dy0), 0], [0, 0, 1]])\n    R = Rz @ R\n    xy = qpos[idx[0], :2].copy()\n    \n    for step_k in range(len(idx) - 1):\n        i0 = idx[step_k]\n        i1 = idx[step_k + 1]\n        # Trapezoidal integration using i0 and i1 proprio!\n        v0 = (R @ proprio[i0, 12:15])[:2]\n        R_mid = R @ exp_so3(0.5 * (proprio[i0, 15:18] + proprio[i1, 15:18]) * dt)\n        R_next = align_gravity(R_mid, proprio[i1, 1:4])\n        v1 = (R_next @ proprio[i1, 12:15])[:2]\n        xy = xy + 0.5 * (v0 + v1) * dt\n        R = R_next\n        \n        true_xy = qpos[i1, :2]\n        true_yaw = heading(qpos[i1, 3:7])\n        est_yaw = np.arctan2(R[1, 0], R[0, 0])\n        dyaw = abs((est_yaw - true_yaw + np.pi) % (2 * np.pi) - np.pi)\n        dxy = np.linalg.norm(xy - true_xy)\n        if step_k + 1 == 20:\n            errs_1s.append(dxy); yaw_1s.append(np.degrees(dyaw))\n        elif step_k + 1 == 100:\n            errs_5s.append(dxy); yaw_5s.append(np.degrees(dyaw))\n        elif step_k + 1 == 399:\n            errs_20s.append(dxy); yaw_20s.append(np.degrees(dyaw))\n\nprint(f\"1s  (20 ticks):  pos err = {np.mean(errs_1s):.4f} m, yaw err = {np.mean(yaw_1s):.3f} deg\")\nprint(f\"5s  (100 ticks): pos err = {np.mean(errs_5s):.4f} m, yaw err = {np.mean(yaw_5s):.3f} deg\")\nprint(f\"20s (400 ticks): pos err = {np.mean(errs_20s):.4f} m, yaw err = {np.mean(yaw_20s):.3f} deg\")\n'\n","e":0,"o":"1s  (20 ticks):  pos err = 0.0107 m, yaw err = 0.908 deg\n5s  (100 ticks): pos err = 0.1504 m, yaw err = 3.113 deg\n20s (400 ticks): pos err = 0.5735 m, yaw err = 7.780 deg","d":3.1}]},{"t":630.6,"$":0.057,"c":[{"n":"bash","a":"python3 -c '\nimport numpy as np\nfrom newrooms import families, maze, appearance, geometry, journeys, render\nfrom newrooms.world import World, heading\nfrom newrooms.locomotion import Motor\n\n# Test Motor across extreme Stratum-3 physics corners!\nspec = families.sample_maze(0)\n# Create an open room to test straight walking + sharp 90/180 turns, and also a corridor maze\nresults = []\nfor fric in (0.5, 1.0, 2.0):\n    for mass in (0.65, 1.0, 1.55):\n        for gear in (0.65, 1.0, 1.55):\n            case = {\n                \"layout\": spec[\"layout\"],\n                \"appearance\": spec[\"appearance\"],\n                \"physics\": {\"friction\": fric, \"mass\": mass, \"gear\": gear},\n                \"closed\": [],\n                \"start\": [10.0, 10.0, 0.0],\n                \"goal\": [40.0, 40.0],\n                \"goal_yaw\": 0.0,\n                \"seed\": 42,\n            }\n            w = World(case, render=False)\n            motor = Motor()\n            flipped = False\n            dists = []\n            prev_xy = w.data.qpos[:2].copy()\n            # Follow a rotating target direction every 60 ticks (90 deg turns + 180 turn)\n            targets = [0.0, np.pi/2, np.pi, -np.pi/2, np.pi/4, -3*np.pi/4]\n            for t in range(360):\n                body = w.body()\n                if body[3] > -0.2: # gravity_z in body frame > -0.2 => tilted > 78 deg / upside down\n                    flipped = True\n                yaw = heading(w.data.qpos[3:7])\n                des_world = targets[(t // 60) % len(targets)]\n                rel = des_world - yaw\n                direction = [np.cos(rel), np.sin(rel)]\n                act = motor(body, direction)\n                w.advance(act, 0.05)\n                if (t + 1) % 60 == 0:\n                    xy = w.data.qpos[:2].copy()\n                    dists.append(np.linalg.norm(xy - prev_xy) / 3.0)\n                    prev_xy = xy\n            results.append((fric, mass, gear, flipped, np.mean(dists), w.data.qpos[2]))\n\nflipped_cases = [r for r in results if r[3]]\nprint(f\"Tested {len(results)} physics combinations. Flipped count: {len(flipped_cases)}\")\nfor r in sorted(results, key=lambda x: x[4])[:6]:\n    print(f\"  Slowest: fric={r[0]:.2f} mass={r[1]:.2f} gear={r[2]:.2f} flipped={r[3]} speed={r[4]:.2f} u/s z={r[5]:.2f}\")\nfor r in sorted(results, key=lambda x: -x[4])[:6]:\n    print(f\"  Fastest: fric={r[0]:.2f} mass={r[1]:.2f} gear={r[2]:.2f} flipped={r[3]} speed={r[4]:.2f} u/s z={r[5]:.2f}\")\nif flipped_cases:\n    for r in flipped_cases:\n        print(f\"  FLIPPED: fric={r[0]:.2f} mass={r[1]:.2f} gear={r[2]:.2f} speed={r[4]:.2f} u/s z={r[5]:.2f}\")\n'\n","e":0,"o":"Tested 27 physics combinations. Flipped count: 4\n  Slowest: fric=0.50 mass=0.65 gear=1.55 flipped=True speed=0.36 u/s z=0.26\n  Slowest: fric=0.50 mass=0.65 gear=0.65 flipped=False speed=0.57 u/s z=0.43\n  Slowest: fric=2.00 mass=0.65 gear=1.00 flipped=False speed=0.60 u/s z=0.52\n  Slowest: fric=2.00 mass=0.65 gear=0.65 flipped=False speed=0.62 u/s z=0.66\n  Slowest: fric=2.00 mass=1.55 gear=0.65 flipped=False speed=0.64 u/s z=0.54\n  Slowest: fric=0.50 mass=1.00 gear=0.65 flipped=False speed=0.65 u/s z=0.52\n  Fastest: fric=0.50 mass=1.00 gear=1.55 flipped=False speed=1.16 u/s z=0.65\n  Fastest: fric=1.00 mass=1.00 gear=1.55 flipped=False speed=1.03 u/s z=0.56\n  Fastest: fric=1.00 mass=0.65 gear=1.55 flipped=False speed=1.01 u/s z=0.73\n  Fastest: fric=1.00 mass=1.55 gear=1.00 flipped=False speed=0.98 u/s z=0.60\n  Fastest: fric=0.50 mass=1.00 gear=1.00 flipped=False speed=0.97 u/s z=0.49\n  Fastest: fric=1.00 mass=0.65 gear=1.00 flipped=False speed=0.94 u/s z=0.50\n  FLIPPED: fric=0.50 mass=0.65 gear=1.55 speed=0.36 u/s z=0.26\n  FLIPPED: fric=0.50 mass=1.55 gear=1.55 speed=0.82 u/s z=0.26\n  FLIPPED: fric=2.00 mass=0.65 gear=1.55 speed=0.83 u/s z=0.32\n  FLIPPED: fric=2.00 mass=1.55 gear=1.55 speed=0.81 u/s z=0.25","d":10}]},{"t":679.7,"$":0.0414,"c":[{"n":"bash","a":"python3 -c '\nimport numpy as np\nfrom newrooms import families\nfrom newrooms.world import World, heading\nfrom newrooms.locomotion import Motor\n\nspec = families.sample_maze(0)\nflipped_cnt = 0\nspeeds = []\nfor fric in (0.5, 1.0, 2.0):\n    for mass in (0.65, 1.0, 1.55):\n        for gear in (0.65, 1.0, 1.55):\n            case = {\n                \"layout\": spec[\"layout\"],\n                \"appearance\": spec[\"appearance\"],\n                \"physics\": {\"friction\": fric, \"mass\": mass, \"gear\": gear},\n                \"closed\": [],\n                \"start\": [10.0, 10.0, 0.0],\n                \"goal\": [40.0, 40.0],\n                \"goal_yaw\": 0.0,\n                \"seed\": 42,\n            }\n            w = World(case, render=False)\n            motor = Motor()\n            flipped = False\n            dists = []\n            prev_xy = w.data.qpos[:2].copy()\n            targets = [0.0, np.pi/2, np.pi, -np.pi/2, np.pi/4, -3*np.pi/4]\n            # Online joint-response gain estimator (no privileged physics!)\n            gain_est = 1.0\n            prev_qvel = None\n            prev_act = np.zeros(8)\n            for t in range(360):\n                body = w.body()\n                qvel_j = np.asarray(body[18:26])\n                if prev_qvel is not None and np.linalg.norm(prev_act) > 0.3:\n                    # Estimate responsiveness |dqvel| / |act|\n                    ratio = np.linalg.norm(qvel_j - prev_qvel) / (np.linalg.norm(prev_act) + 1e-6)\n                    # Nominal ratio is around ~2.8; if high gear / low mass, ratio > 3.5\n                    gain_est = 0.95 * gain_est + 0.05 * np.clip(2.8 / max(ratio, 0.5), 0.55, 1.0)\n                prev_qvel = qvel_j\n                if body[3] > -0.2:\n                    flipped = True\n                # Also damp torque if torso tilts (gravity_z > -0.88 means > 28 deg tilt)\n                tilt_scale = np.clip((-body[3] - 0.5) / 0.4, 0.25, 1.0)\n                yaw = heading(w.data.qpos[3:7])\n                des_world = targets[(t // 60) % len(targets)]\n                rel = des_world - yaw\n                act = motor(body, [np.cos(rel), np.sin(rel)]) * min(gain_est, tilt_scale)\n                prev_act = act\n                w.advance(act, 0.05)\n                if (t + 1) % 60 == 0:\n                    xy = w.data.qpos[:2].copy()\n                    dists.append(np.linalg.norm(xy - prev_xy) / 3.0)\n                    prev_xy = xy\n            if flipped: flipped_cnt += 1\n            speeds.append(np.mean(dists))\nprint(f\"With online gain+tilt guard: flipped = {flipped_cnt}/27, min speed = {min(speeds):.2f}, mean speed = {np.mean(speeds):.2f}, max speed = {max(speeds):.2f}\")\n'\necho \"=== Dry run check on GPU ===\"\nlab gpu run --dry-run --gpus 1 --max-minutes 10 -- python3 -c \"import os; print(os.listdir('/opt/newrooms/data')[:5])\"\n","e":0,"o":"With online gain+tilt guard: flipped = 1/27, min speed = 0.54, mean speed = 0.81, max speed = 1.03\n=== Dry run check on GPU ===\n{\n  \"quote\": {\n    \"max_hold_microusd\": 630000,\n    \"price_per_gpu_minute_microusd\": 63000,\n    \"gpus\": 1,\n    \"max_minutes\": 10,\n    \"image\": \"research\",\n    \"inputs_bytes\": 0,\n    \"wallet_available_microusd\": 85000000,\n    \"admissible\": true,\n    \"refusal\": null\n  },\n  \"note\": \"A quote reserves nothing and is not a capacity guarantee\"\n}","d":11.2}]},{"t":705.5,"$":0.0198,"c":[{"n":"bash","a":"lab papers search 'ti:\"visual navigation\" AND (ti:\"goal\" OR abs:\"goal image\")' --max 10\nlab papers search 'ti:\"OGBench\" OR abs:\"OGBench\"' --max 5\n","e":0,"o":["{\n  \"total\": 9,\n  \"start\": 0,\n  \"entries\": [\n    {\n      \"id\": \"2206.07423v3\",\n      \"title\": \"Zero-shot object goal visual navigation\",\n      \"authors\": [\n        \"Qianfan Zhao\",\n        \"Lu Zhang\",\n        \"Bin He\",\n        \"Hong Qiao\",\n        \"Zhiyong Liu\"\n      ],\n      \"published\": \"2022-06-15T09:53:43Z\",\n      \"updated\": \"2023-02-20T03:46:36Z\",\n      \"categories\": [\n        \"cs.CV\",\n        \"cs.AI\"\n      ],\n      \"primary_category\": \"cs.CV\",\n      \"summary\": \"Object goal visual navigation is a challenging task that aims to guide a robot to find the target object based on its visual observation, and the target is limited to the classes pre-defined in the training stage. However, in real households, there may exist numerous target classes that the robot needs to deal with, and it is hard for all of these classes to be contained in the training stage. To address this challenge, we study the zero-shot object goal visual navigation task, which aims at guiding robots to find targets belonging to novel classes without any training samples. To this end, we also propose a novel zero-shot object navigation framework called semantic similarity network (SSNet). Our framework use the detection results and the cosine similarity between semantic word embeddings as input. Such type of input data has a weak correlation with classes and thus our framework has the ability to generalize the policy to novel classes. Extensive experiments on the AI2-THOR platform show that our model outperforms the baseline models in the zero-shot object navigation task, which proves the generalization ability of our model. Our code is available at: https://github.com/pioneer-innovation/Zero-Shot-Object-Navigation.\"\n    },\n    {\n      \"id\": \"2508.09547v1\",\n      \"title\": \"GoViG: Goal-Conditioned Visual Navigation Instruction Generation\",\n      \"authors\": [\n        \"Fengyi Wu\",\n        \"Yifei Dong\",\n        \"Zhi-Qi Cheng\",\n        \"Yilong Dai\",\n        \"Guangyu Chen\",\n        \"Hang Wang\",\n        \"Qi Dai\",\n        \"Alexander G. Hauptmann\"\n      ],\n      \"published\": \"2025-08-13T07:05:17Z\",\n      \"updated\": \"2025-08-13T07:05:17Z\",\n      \"categories\": [\n        \"cs.CV\",\n        \"cs.AI\"\n      ],\n      \"primary_category\": \"cs.CV\",\n",20056,"      \"updated\": \"2025-10-08T07:07:39Z\",\n      \"categories\": [\n        \"cs.LG\",\n        \"cs.AI\"\n      ],\n      \"primary_category\": \"cs.LG\",\n      \"summary\": \"In this work, we introduce dual goal representations for goal-conditioned reinforcement learning (GCRL). A dual goal representation characterizes a state by \\\"the set of temporal distances from all other states\\\"; in other words, it encodes a state through its relations to every other state, measured by temporal distance. This representation provides several appealing theoretical properties. First, it depends only on the intrinsic dynamics of the environment and is invariant to the original state representation. Second, it contains provably sufficient information to recover an optimal goal-reaching policy, while being able to filter out exogenous noise. Based on this concept, we develop a practical goal representation learning method that can be combined with any existing GCRL algorithm. Through diverse experiments on the OGBench task suite, we empirically show that dual goal representations consistently improve offline goal-reaching performance across 20 state- and pixel-based tasks.\"\n    }\n  ]\n}"],"d":1.4}]}],"parts":[107,109,97]}