SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2410.02730 · 2024

DivScene: Towards Open-Vocabulary Object Navigation with Large Vision Language Models in Diverse Scenes

arXiv · PDF · Open in the Atlas

Code that ran

15 of 15 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 12 failures of our instrument; 0 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2410.02730.json · badge: /api/ran/2410.02730.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
zhaowei-wang-nlp/divscene canonical (classifier label)
classifier basis: census
15 ran · 0 no recorded run
FunctionStatusWhere it lives
calculate_path_length Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_metric.py
code served (permissive licence) · get_code("c398e46c3e1c3747")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import random
import math

def calculate_path_length(path_list):
    total_length = 0
    for i in range(1, len(path_list)):
        x1, y1 = path_list[i - 1]
        x2, y2 = path_list[i]
        distance = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
        total_length += distance
    return total_length

# Construct a valid path_list
# The function expects an iterable of coordinate tuples (x, y)
path_list = [
    (0.0, 0.0),
    (3.0, 4.0),
    (6.0, 8.0),
    (10.0, 8.0),
]

ARGS = {
    "path_list": path_list
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_pair_to_str Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/reformat_data/diff_utils.py
code served (permissive licence) · get_code("4259267f7d4a7e91")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function convert_pair_to_str takes a pair (indexable with [0] and [1])
# and formats each element to 2 decimal places.
# The simplest valid pair is a tuple or list with two numeric values.

pair = (3.14159, 2.71828)

ARGS = {
    'pair': pair
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
extract_object_type Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/reformat_data/diff_utils.py
code served (permissive licence) · get_code("005fdbd14f429fc0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

def extract_object_type(object_id):
    object_part = object_id.split('|')[0]
    object_type = object_part.split('-')[0]
    return object_type

ARGS = {
    'object_id': 'car-sedan|instance_5'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
format_args Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/agent_inference/utils.py
code served (permissive licence) · get_code("f3f346ac0d3677e3")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

from dataclasses import dataclass

@dataclass
class Args:
    learning_rate: float = 0.001
    batch_size: int = 32
    num_epochs: int = 10
    model_name: str = "bert-base"
    dropout: float = 0.1

ARGS = {
    "args": Args()
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_cur_diff Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/reformat_data/diff_utils.py
code served (permissive licence) · get_code("9f5266890fdc41a6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyzing the function get_cur_diff:
# - r: an integer representing rotation/direction (90, 270, or other values like 0, 180)
# - p: a tuple/list with at least 2 elements representing current position [x, y]
# - target_agent_pos: a tuple/list with at least 2 elements representing target position [x, y]

# The function accesses:
# - r as a key in direction_text_mapping dict
# - p[0], p[1] as numeric values
# - target_agent_pos[0], target_agent_pos[1] as numeric values
# - Performs arithmetic operations on these values

# Create valid arguments
r = 90  # rotation value that exists in direction_text_mapping
p = (5.5, 3.2)  # current position as tuple
target_agent_pos = (8.1, 3.2)  # target position as tuple

ARGS = {
    'r': r,
    'p': p,
    'target_agent_pos': target_agent_pos
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_cur_diff Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/reformat_data/utils.py
code served (permissive licence) · get_code("346ba3a0aa9a8e55")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function:
# - r: an integer that is checked against {90, 270} and used as a key in direction_text_mapping
# - p_diff: a sequence/array that supports indexing [0] and [1], contains numeric values

# Create test arguments
r = 90  # This will trigger the first branch (r in {90, 270})
p_diff = np.array([5, -3])  # [0] is 5 (positive, east), [1] is -3 (negative, south)

ARGS = {
    'r': r,
    'p_diff': p_diff
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_shortest_path_to_point Ran
ran, honoured the contract we drafted
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_online_client.py
code served (permissive licence) · get_code("44465377eaacf505")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

class MockController:
    def __init__(self):
        self.call_count = 0
    
    def step(self, kwargs):
        self.call_count += 1
        return MockEvent()

class MockEvent:
    def __init__(self):
        self.metadata = {
            'lastActionSuccess': True,
            'actionReturn': {
                'corners': [
                    [0.5, 0.0, 0.5],
                    [1.5, 0.0, 0.5],
                    [1.5, 0.0, 1.5],
                    [0.5, 0.0, 1.5]
                ]
            },
            'errorMessage': None
        }

controller = MockController()
initial_position = {'x': 0.0, 'y': 0.0, 'z': 0.0}
target_position = {'x': 1.0, 'y': 0.0, 'z': 1.0}

ARGS = {
    'controller': controller,
    'initial_position': initial_position,
    'target_position': target_position
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_type_dict Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_gpt4o.py
code served (permissive licence) · get_code("b297d01d782e10b4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Analyze the function: get_type_dict takes my_dict and returns a dict
# where keys are the original keys and values are the types of the original values.
# The function iterates over my_dict.items() and calls type() on each value.

# Create a diverse dictionary with various types to demonstrate the function
my_dict = {
    "tensor": torch.randn(2, 4),
    "numpy_array": np.array([1, 2, 3]),
    "integer": 42,
    "string": "hello",
    "list": [1, 2, 3],
    "float": 3.14,
    "dict": {"nested": "value"},
    "boolean": True,
}

ARGS = {
    "my_dict": my_dict,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
init_logger Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/agent_inference/utils.py
code served (permissive licence) · get_code("4650a677e33f265a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned RootLogger. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import logging
import os
import sys
import tempfile
import datasets
import transformers

# Create a temporary directory for output
temp_dir = tempfile.mkdtemp()

# Create a minimal training_args object with the required output_dir attribute
class MinimalTrainingArgs:
    def __init__(self, output_dir):
        self.output_dir = output_dir

training_args = MinimalTrainingArgs(output_dir=temp_dir)
log_level = logging.INFO

ARGS = {
    "training_args": training_args,
    "log_level": log_level,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
datasets, transformers — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RootLogger — a RootLogger output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a RootLogger output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
map_action_to_id Ran
ran, honoured the contract we drafted
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_gpt4o.py
code served (permissive licence) · get_code("b43f513176e6bbfe")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

action_list = ['MoveAhead', 'RotateRight', 'RotateLeft', 'Done']

a2i = {'moveahead': 0, 'rotateright': 1, 'rotateleft': 2, 'done': 3}

def map_action_to_id(action_list):
    id_list = [a2i.get(action.lower(), -1) for action in action_list]
    return id_list

ARGS = {
    'action_list': ['MoveAhead', 'RotateRight', 'RotateLeft', 'Done']
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
map_action_to_id Ran
ran, honoured the contract we drafted
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_server.py
code served (permissive licence) · get_code("e04797a75615b923")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

a2i = {'moveahead': 0, 'rotateright': 1, 'rotateleft': 2, 'lookup': 3, 'done': 4}

def map_action_to_id(action_list):
    id_list = [a2i.get(action.lower(), -1) for action in action_list]
    return id_list

# Construct valid arguments
action_list = ['MoveAhead', 'RotateRight', 'RotateLeft', 'LookUp', 'Done', 'InvalidAction']

ARGS = {
    'action_list': action_list
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family int — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_action Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_gpt4o.py
code served (permissive licence) · get_code("b6552010f6d8a287")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

action_set = {'MoveAhead', 'RotateRight', 'RotateLeft', 'Done'}

def parse_action(output_str):
    output_str = output_str.strip()
    try:
        output_str = output_str[output_str.index('3)') + 2:].strip()
    except Exception as e:
        pass
    output_str_set = output_str.split()
    for seg in output_str_set:
        if seg in action_set:
            return seg
    for action in action_set:
        if action in output_str:
            return action
    return 'None'

# Test cases for output_str parameter
output_str_1 = "The action is 3) MoveAhead forward"
output_str_2 = "RotateLeft is the best action"
output_str_3 = "3) Done with task"
output_str_4 = "some random text without action"

ARGS = {
    'output_str': output_str_1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_action Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_online_client.py
code served (permissive licence) · get_code("7a16f1f9f950f857")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

action_set = {'MoveAhead', 'RotateRight', 'RotateLeft', 'Done'}

def parse_action(output_str):
    output_str = output_str.strip()
    if output_str.startswith('Assistant:'):
        output_str = output_str[len('Assistant:'):].strip()
    try:
        output_str = output_str[output_str.index('3)') + 2:].strip()
    except Exception as e:
        pass
    output_str = output_str.split()
    for seg in output_str:
        if seg in action_set:
            return seg
    return 'None'

# Test case 1: Simple action string
test_output_1 = "MoveAhead"

# Test case 2: With "Assistant:" prefix
test_output_2 = "Assistant: RotateRight"

# Test case 3: With "3)" marker
test_output_3 = "Some text 3) RotateLeft extra"

# Test case 4: Complex case with all features
test_output_4 = "Assistant: Some reasoning 3) Done is the action"

# Test case 5: No valid action
test_output_5 = "Assistant: This has no valid action"

ARGS = {
    "output_str": "Assistant: Some text 3) MoveAhead next"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_action Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/agent_inference/hf_idefics2_server.py
code served (permissive licence) · get_code("a24d87222eb1a622")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

action_set = {'MoveAhead', 'RotateRight', 'RotateLeft', 'LookUp', 'Done'}

# Test case 1: Simple string with action at start
output_str_1 = "MoveAhead"

# Test case 2: String with ASSISTANT prefix
output_str_2 = "ASSISTANT: RotateRight is next"

# Test case 3: String with 3) marker
output_str_3 = "Some text 3) LookUp and continue"

# Test case 4: String with action embedded in a word
output_str_4 = "The action is MoveAhead_now"

# Test case 5: String with no valid action
output_str_5 = "No action here"

# Test case 6: String with whitespace and Done action
output_str_6 = "   Done   "

ARGS = {
    "output_str": "ASSISTANT: Some context 3) RotateLeft should be executed"
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
revise_mnli_models Ran
ran; our contract draft was wrong, not the code
zhaowei-wang-nlp/divscene/agent_inference/utils.py
code served (permissive licence) · get_code("a7b36e290c6f5fc1")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned RobertaModel. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

# Create a minimal RoBERTa-style model
class RobertaClassificationHead(nn.Module):
    def __init__(self, hidden_size=4, num_labels=3):
        super().__init__()
        self.out_proj = nn.Linear(hidden_size, num_labels)

class RobertaModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.classifier = RobertaClassificationHead(hidden_size=4, num_labels=3)
        self.config = type('Config', (), {'num_labels': 3})()

# Initialize the model
mnli_model = RobertaModel()

# Set up the linear layer with proper weights and biases
with torch.no_grad():
    mnli_model.classifier.out_proj.weight.data = torch.randn(3, 4)
    mnli_model.classifier.out_proj.bias.data = torch.randn(3)

# Define arguments
ARGS = {
    'model_name_or_path': 'roberta-base',
    'mnli_model': mnli_model,
    'neutral_id': 0,
    'entail_id': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RobertaModel — a RobertaModel output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a RobertaModel output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 14 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 14 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Large Vision-Language Models (LVLMs) have achieved significant progress in tasks like visual question answering and document understanding. However, their potential to comprehend embodied environments and navigate within them remains underexplored. In this work, we first study the challenge of open-vocabulary object navigation by introducing DivScene, a large-scale dataset with 4,614 houses across 81 scene types and 5,707 kinds of target objects. Our dataset provides a much greater diversity of target objects and scene types than existing datasets, enabling a comprehensive task evaluation. We evaluated various methods with LVLMs and LLMs on our dataset and found that current models still fall short of open-vocab object navigation ability. Then, we fine-tuned LVLMs to predict the next action with CoT explanations. We observe that LVLM's navigation ability can be improved substantially with only BFS-generated shortest paths without any human supervision, surpassing GPT-4o by over 20% in success rates.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2410.02730")
get_code_for_paper("2410.02730")
have("2410.02730")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2410.02730.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2410.02730.svg)](https://syntology.ai/paper/2410.02730)

Connect an agent — have() is free.