SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1012.2599 · 2010

A Tutorial on Bayesian Optimization of Expensive Cost Functions, with Application to Active User Modeling and Hierarchical Reinforcement Learning

arXiv · PDF · Open in the Atlas

Code that ran

14 of 16 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; 0 honoured the contract we drafted, 0 violated it and 14 have no contract verdict; 0 failures of our instrument; 2 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/1012.2599.json · badge: /api/ran/1012.2599.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
Somya-Patra/Shell_ai community (classifier label)
classifier basis not recorded on the link
6 ran · 0 no recorded run
chariff/GPro community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
bayesian-optimization/bayesianoptimization community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
yanpei18345156216/BayesianOptimization community (classifier label)
classifier basis not recorded on the link
2 ran · 1 no recorded run
zatang007/BayesianOptimization community (classifier label)
classifier basis not recorded on the link
0 ran · 1 no recorded run
FunctionStatusWhere it lives
binWindResourceData Ran
ran on a synthesized input
Somya-Patra/Shell_ai/Farm_Evaluator.py
code served (permissive licence) · get_code("413ed572d7960e61")
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 ndarray, ndim 2, dtype family float, shape (36, 15) 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 numpy as np
import pandas as pd
import tempfile
import os

# Create a temporary CSV file with wind data
temp_dir = tempfile.mkdtemp()
wind_data_file = os.path.join(temp_dir, 'wind_data.csv')

# Create sample wind resource data
# The function expects columns 'drct' (direction) and 'sped' (speed)
wind_data = {
    'drct': np.concatenate([
        np.full(50, 360),   # 50 samples at direction 360
        np.full(50, 10),    # 50 samples at direction 10
        np.full(50, 20),    # 50 samples at direction 20
        np.full(50, 30),    # 50 samples at direction 30
    ]),
    'sped': np.concatenate([
        np.random.uniform(0, 2, 50),      # speeds in [0, 2)
        np.random.uniform(2, 4, 50),      # speeds in [2, 4)
        np.random.uniform(4, 6, 50),      # speeds in [4, 6)
        np.random.uniform(6, 8, 50),      # speeds in [6, 8)
    ])
}

df = pd.DataFrame(wind_data)
df.to_csv(wind_data_file, index=False)

ARGS = {
    'wind_data_file_name': wind_data_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (36, 15) — shape (36, 15) 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
binWindResourceData Ran
ran on a synthesized input
Somya-Patra/Shell_ai/Farm_Evaluator_Vec.py
code served (permissive licence) · get_code("ffbab055fda03000")
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 ndarray, ndim 1, dtype family float, shape (540,) 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 numpy as np
import pandas as pd
import tempfile
import os

# Create a temporary CSV file with wind data
temp_dir = tempfile.gettempdir()
wind_data_file = os.path.join(temp_dir, "wind_data_test.csv")

# Generate sample wind data with directions and speeds
np.random.seed(0)
n_samples = 1000

directions = np.random.choice([360, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250, 260, 270, 280, 290, 300, 310, 320, 330, 340, 350], n_samples)
speeds = np.random.uniform(0, 30, n_samples)

wind_df = pd.DataFrame({
    'drct': directions,
    'sped': speeds
})

wind_df.to_csv(wind_data_file, index=False)

ARGS = {
    'wind_data_file_name': wind_data_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (540,) — shape (540,) 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
check_x_m Ran
ran on a synthesized input
chariff/GPro/GPro/validations.py
code served (permissive licence) · get_code("8c4758f81e72fde5")
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. 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 numpy as np

# Create valid x: 2D array with floating point data
# Shape (4, 3) - 4 samples, 3 features
x = np.array([
    [1.0, 2.0, 3.0],
    [4.0, 5.0, 6.0],
    [7.0, 8.0, 9.0],
    [10.0, 11.0, 12.0]
], dtype=np.float64)

# Create valid m: 2D array with integer preferences
# Shape (2, 2) - 2 preference pairs
# Each row is [index1, index2] where index1 and index2 are different and < x.shape[0]
m = np.array([
    [0, 1],
    [2, 3]
], dtype=np.int16)

ARGS = {
    'x': x,
    'm': m
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is 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
convert_array Ran
ran on a synthesized input
chariff/GPro/GPro/validations.py
code served (permissive licence) · get_code("318ddf5331788977")
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 ndarray, ndim 1, dtype family int, shape (5,) 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 numpy as np

# Test case 1: A list input
list_input = [1, 2, 3, 4, 5]

# Test case 2: An already-converted numpy array (should pass through)
array_input = np.array([10, 20, 30])

# Build the ARGS dict
ARGS = {
    "x": list_input
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family int, shape (5,) — shape (5,) 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
ensure_rng Ran
ran on a synthesized input
bayesian-optimization/bayesianoptimization/bayes_opt/util.py
code served (permissive licence) · get_code("4141d9ccb6edc694")
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 RandomState. 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 numpy as np

# Test case 1: None (creates unseeded random state)
random_state_none = None

# Test case 2: int seed
random_state_int = 42

# Test case 3: np.random.RandomState instance
random_state_obj = np.random.RandomState(123)

# Define ARGS dict with all parameter combinations
# We'll test with the int case as the primary example
ARGS = {
    'random_state': 42
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RandomState — a RandomState output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a RandomState 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
ensure_rng Ran
ran on a synthesized input
yanpei18345156216/BayesianOptimization/bayes_opt/util.py
code served (permissive licence) · get_code("df34156cc3c73ffb")
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 RandomState. 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 numpy as np

# Test case 1: None (unseeded)
arg1 = None

# Test case 2: integer seed
arg2 = 42

# Test case 3: existing RandomState
arg3 = np.random.RandomState(123)

ARGS = {
    "random_state": arg1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RandomState — a RandomState output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a RandomState 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
getTurbLoc Ran
ran on a synthesized input
Somya-Patra/Shell_ai/Farm_Evaluator.py
code served (permissive licence) · get_code("a85ca56407c9e58c")
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 ndarray, ndim 2, dtype family float, shape (4, 2) 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 numpy as np
import pandas as pd
import tempfile
import os

# Create a temporary CSV file with turbine coordinates
temp_dir = tempfile.mkdtemp()
turb_loc_file = os.path.join(temp_dir, "turbine_locations.csv")

# Write sample turbine location data to CSV
turb_data = pd.DataFrame({
    'x': [100.5, 200.3, 150.7, 250.2],
    'y': [50.1, 75.4, 120.9, 180.6]
})
turb_data.to_csv(turb_loc_file, index=False, sep=',')

ARGS = {
    'turb_loc_file_name': turb_loc_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (4, 2) — shape (4, 2) 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
getTurbLoc Ran
ran on a synthesized input
Somya-Patra/Shell_ai/Farm_Evaluator_Vec.py
code served (permissive licence) · get_code("a678138a7683f539")
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 ndarray, ndim 2, dtype family float, shape (3, 2) 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 numpy as np
import pandas as pd
import tempfile
import os

# Create a temporary CSV file with turbine coordinates
temp_dir = tempfile.mkdtemp()
csv_file = os.path.join(temp_dir, "turb_loc.csv")

# Write sample turbine location data to CSV
turb_data = pd.DataFrame({
    'x': [100.5, 200.3, 150.7],
    'y': [50.2, 75.9, 120.1]
})
turb_data.to_csv(csv_file, sep=',', index=False)

ARGS = {
    "turb_loc_file_name": csv_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 2) — shape (3, 2) 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
is_numeric Ran
ran on a synthesized input
bayesian-optimization/bayesianoptimization/bayes_opt/parameter.py
code served (permissive licence) · get_code("a2732ed857b86a4f")
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 bool, 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 numpy as np
from numbers import Number

# Test with various numeric types
int_value = 42
float_value = 3.14
numpy_int = np.int32(10)
numpy_float = np.float64(2.71)
numpy_array_int = np.array([1, 2, 3])
numpy_array_float = np.array([1.5, 2.5, 3.5])
non_numeric_string = "hello"
non_numeric_list = [1, 2, 3]

# Create test cases for the function
test_values = [
    int_value,
    float_value,
    numpy_int,
    numpy_float,
    numpy_array_int,
    numpy_array_float,
    non_numeric_string,
    non_numeric_list,
]

# The function takes a single parameter 'value'
# We'll test it with a numeric value as the main use case
ARGS = {
    "value": 42
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, 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
loadPowerCurve Ran
ran on a synthesized input
Somya-Patra/Shell_ai/Farm_Evaluator.py
code served (permissive licence) · get_code("4c6327d53efa913c")
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 ndarray, ndim 2, dtype family float, shape (8, 3) 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 numpy as np
import pandas as pd
import tempfile
import os

# Create a temporary CSV file with power curve data
temp_dir = tempfile.mkdtemp()
power_curve_file = os.path.join(temp_dir, "power_curve.csv")

# Write a simple power curve CSV with Wind Speed, Thrust Coefficient, and Power columns
power_curve_data = pd.DataFrame({
    'Wind Speed (m/s)': [3.0, 5.0, 7.0, 9.0, 11.0, 13.0, 15.0, 25.0],
    'Thrust Coeffecient (non dimensional)': [0.85, 0.88, 0.89, 0.87, 0.85, 0.82, 0.78, 0.0],
    'Power (MW)': [0.0, 0.1, 0.3, 0.6, 1.0, 1.5, 2.0, 2.0]
})
power_curve_data.to_csv(power_curve_file, sep=',', index=False)

ARGS = {
    'power_curve_file_name': power_curve_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (8, 3) — shape (8, 3) 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
loadPowerCurve Ran
ran on a synthesized input
Somya-Patra/Shell_ai/Farm_Evaluator_Vec.py
code served (permissive licence) · get_code("7a9f9a088417e901")
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 ndarray, ndim 2, dtype family float, shape (10, 3) 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 numpy as np
import pandas as pd
import tempfile
import os

# Create a temporary CSV file with power curve data
temp_dir = tempfile.mkdtemp()
power_curve_file = os.path.join(temp_dir, "power_curve.csv")

# Create sample power curve data: Wind Speed (m/s), Thrust Coefficient, Power (MW)
data = {
    'Wind Speed (m/s)': [3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0],
    'Thrust Coefficient': [0.85, 0.88, 0.89, 0.90, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96],
    'Power (MW)': [0.1, 0.3, 0.6, 1.0, 1.5, 2.0, 2.4, 2.7, 2.9, 3.0]
}

df = pd.DataFrame(data)
df.to_csv(power_curve_file, index=False, sep=',')

ARGS = {
    'power_curve_file_name': power_curve_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (10, 3) — shape (10, 3) 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
load_logs Ran
ran on a synthesized input
yanpei18345156216/BayesianOptimization/bayes_opt/util.py
code served (permissive licence) · get_code("9ea6221c39391f78")
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 MockOptimizer. 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 json
import tempfile
import os

# Create a mock optimizer with a register method
class MockOptimizer:
    def __init__(self):
        self.registered = []
    
    def register(self, params, target):
        self.registered.append({'params': params, 'target': target})

# Create temporary log files with JSON lines
temp_dir = tempfile.mkdtemp()
log_file_1 = os.path.join(temp_dir, 'log1.json')
log_file_2 = os.path.join(temp_dir, 'log2.json')

# Write sample JSON lines to log files
with open(log_file_1, 'w') as f:
    f.write(json.dumps({'params': [0.1, 0.2], 'target': 0.5}) + '\n')
    f.write(json.dumps({'params': [0.15, 0.25], 'target': 0.55}) + '\n')

with open(log_file_2, 'w') as f:
    f.write(json.dumps({'params': [0.2, 0.3], 'target': 0.6}) + '\n')
    f.write(json.dumps({'other_key': 'no_params_or_target'}) + '\n')

optimizer = MockOptimizer()
logs = [log_file_1, log_file_2]

ARGS = {
    'optimizer': optimizer,
    'logs': logs
}
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 MockOptimizer — a MockOptimizer output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MockOptimizer 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
set_d_type Ran
ran on a synthesized input
chariff/GPro/GPro/validations.py
code served (permissive licence) · get_code("9403b500f0378050")
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 ndarray, ndim 2, dtype family int, shape (2, 4) 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 numpy as np

ARGS = {
    "x": np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]], dtype=np.float32),
    "d_type": np.int32
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family int, shape (2, 4) — shape (2, 4) 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
wrap_kernel Ran
ran on a synthesized input
bayesian-optimization/bayesianoptimization/bayes_opt/parameter.py
code served (permissive licence) · get_code("ff62b00813ad9177")
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 WrappedKernel. 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 numpy as np
from sklearn.gaussian_process import kernels

# Define a simple transformation function
def simple_transform(X):
    """A simple transformation that scales input by 2"""
    if X is None:
        return None
    return X * 2

# Create a base kernel to wrap
base_kernel = kernels.RBF(length_scale=1.0)

# Create sample data for testing
X_sample = np.array([[1.0, 2.0, 3.0, 4.0],
                     [5.0, 6.0, 7.0, 8.0]])
Y_sample = np.array([[0.5, 1.5, 2.5, 3.5],
                     [4.5, 5.5, 6.5, 7.5]])

ARGS = {
    "kernel": base_kernel,
    "transform": simple_transform
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type WrappedKernel — a WrappedKernel output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a WrappedKernel 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
acq_max Not yet run
unverified (harvested, no recorded run)
yanpei18345156216/BayesianOptimization/bayes_opt/util.py
code served (permissive licence) · get_code("ed4879c467fcdafe")
How it ran

no invocation recorded.

acq_max Not yet run
unverified (harvested, no recorded run)
zatang007/BayesianOptimization/bayes_opt/util.py
code served (permissive licence) · get_code("f92864c1c6fdc72e")
How it ran

no invocation recorded.

Also present in other papers' code

Of 16 samples lifted from this paper's linked repositories, 16 carry a function identity and 0 do not. Of the 16 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 16 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

We present a tutorial on Bayesian optimization, a method of finding the maximum of expensive cost functions. Bayesian optimization employs the Bayesian technique of setting a prior over the objective function and combining it with evidence to get a posterior function. This permits a utility-based selection of the next observation to make on the objective function, which must take into account both exploration (sampling from areas of high uncertainty) and exploitation (sampling areas likely to offer improvement over the current best observation). We also present two detailed extensions of Bayesian optimization, with experiments---active user modelling with preferences, and hierarchical reinforcement learning---and a discussion of the pros and cons of Bayesian optimization based on our experiences.

For agents

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

get_harvested_code_for_paper("1012.2599")
get_code_for_paper("1012.2599")
have("1012.2599")

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

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

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

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

Connect an agent — have() is free.