| comm_export_pipelines |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_plot_pipeline_matrix.py code served (permissive licence) · get_code("cb700fb13b74cafb") How it ranRan 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 torch.nn as nn
torch.manual_seed(0)
# The function expects msg to be a dict with a 'pipelines' key
# The value should be a list of pipelines (or any serializable structure)
pipelines = [
{
'name': 'pipeline_1',
'stages': ['stage_a', 'stage_b']
},
{
'name': 'pipeline_2',
'stages': ['stage_c']
}
]
msg = {
'pipelines': pipelines
}
ARGS = {
'msg': msg
}
- 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 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
|
| compute_edge_type |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_similarity_flooding.py code served (permissive licence) · get_code("468aa06640e32104") How it ranRan 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 networkx as nx
torch.manual_seed(0)
# Build a simple directed graph with nodes that have the required 'data' structure
g = nx.DiGraph()
# Add nodes with 'data' attribute containing python_path information
g.add_node(0, data=[{'python_path': 'module.submodule.ClassA'}])
g.add_node(1, data=[{'python_path': 'module.submodule.ClassB'}])
g.add_node(2, data=[{'python_path': 'other.Class'}])
# Add edges to the graph
g.add_edge(0, 1)
g.add_edge(1, 2)
# Define the edge to compute the type for
edge = (0, 1)
ARGS = {
'g': g,
'edge': edge
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- networkx, 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
|
| create_pairwise_conn_graph |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_similarity_flooding.py code served (permissive licence) · get_code("093743a6ad664cab") How it ranRan 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 DiGraph. 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 networkx as nx
def create_graph_with_nodes_and_edges(num_nodes, num_edges):
"""Helper to create a graph with proper node structure"""
g = nx.DiGraph()
# Add nodes with the required 'data' structure
for i in range(num_nodes):
# Vary python_path to create different node types
if i == 0:
python_path = "module.submodule.NodeTypeA"
elif i == 1:
python_path = "module.submodule.NodeTypeB"
else:
python_path = "module.submodule.NodeTypeC"
g.add_node(i, data=[{'python_path': python_path}])
# Add edges between nodes
edges_added = 0
for src in range(num_nodes):
for dst in range(num_nodes):
if src != dst and edges_added < num_edges:
g.add_edge(src, dst)
edges_added += 1
if edges_added >= num_edges:
break
if edges_added >= num_edges:
break
return g
# Create two graphs with matching edge types
g1 = create_graph_with_nodes_and_edges(num_nodes=4, num_edges=2)
g2 = create_graph_with_nodes_and_edges(num_nodes=4, num_edges=2)
# Ensure g1 and g2 have matching edge types by controlling their structure
# g1: edges between nodes with specific types
g1 = nx.DiGraph()
g1.add_node(0, data=[{'python_path': 'module.submodule.TypeA'}])
g1.add_node(1, data=[{'python_path': 'module.submodule.TypeB'}])
g1.add_node(2, data=[{'python_path': 'module.submodule.TypeC'}])
g1.add_edge(0, 1) # TypeA -> TypeB
g1.add_edge(1, 2) # TypeB -> TypeC
# g2: same edge type pattern
g2 = nx.DiGraph()
g2.add_node(0, data=[{'python_path': 'module.submodule.TypeA'}])
g2.add_node(1, data=[{'python_path': 'module.submodule.TypeB'}])
g2.add_node(2, data=[{'python_path': 'module.submodule.TypeC'}])
g2.add_edge(0, 1) # TypeA -> TypeB
g2.add_edge(1, 2) # TypeB -> TypeC
ARGS = {
'g1': g1,
'g2': g2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- networkx — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DiGraph — a DiGraph output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DiGraph output the recorded ndim 2 and dtype family int 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_coef_matrix |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/Experimental/FeatureWeights.py code served (permissive licence) · get_code("981f88dd9636a989") How it ranRan 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.
from sklearn import preprocessing
import numpy as np
def extract_primitive_names(pipeline):
return [s['primitive']['name'] for s in pipeline['steps']]
# Create sample pipelines with the expected structure
pipelines = [
{
'steps': [
{'primitive': {'name': 'preprocessor'}},
{'primitive': {'name': 'scaler'}},
]
},
{
'steps': [
{'primitive': {'name': 'scaler'}},
{'primitive': {'name': 'classifier'}},
]
},
{
'steps': [
{'primitive': {'name': 'preprocessor'}},
{'primitive': {'name': 'classifier'}},
]
},
]
ARGS = {
'pipelines': pipelines
}
- 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 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
|
| extract_primitive_matrix |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_powerset_analysis.py code served (permissive licence) · get_code("02b0b27a25321f61") How it ranRan 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
from sklearn import preprocessing
# Create sample pipelines with the expected structure
pipelines = [
{
'steps': [
{'primitive': {'python_path': 'sklearn.preprocessing.StandardScaler'}},
{'primitive': {'python_path': 'sklearn.tree.DecisionTreeClassifier'}},
]
},
{
'steps': [
{'primitive': {'python_path': 'sklearn.preprocessing.MinMaxScaler'}},
{'primitive': {'python_path': 'sklearn.ensemble.RandomForestClassifier'}},
{'primitive': {'python_path': 'sklearn.preprocessing.StandardScaler'}},
]
},
{
'steps': [
{'primitive': {'python_path': 'sklearn.tree.DecisionTreeClassifier'}},
]
},
]
ARGS = {
'pipelines': pipelines
}
- 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 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
|
| extract_primitive_names |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_powerset_analysis.py code served (permissive licence) · get_code("8f8cace5414ad119") How it ranRan 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 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
def extract_primitive_names(pipeline):
return [s['primitive']['python_path'] for s in pipeline['steps']]
ARGS = {
'pipeline': {
'steps': [
{
'primitive': {
'python_path': 'module.primitive_1'
}
},
{
'primitive': {
'python_path': 'module.primitive_2'
}
},
{
'primitive': {
'python_path': 'module.primitive_3'
}
}
]
}
}
- 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 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
|
| extract_primitive_names |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/Experimental/FeatureWeights.py code served (permissive licence) · get_code("e83e9f9bff219c2f") How it ranRan 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 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
# Construct a valid pipeline dict that matches the structure expected by extract_primitive_names
pipeline = {
'steps': [
{
'primitive': {
'name': 'preprocessing'
}
},
{
'primitive': {
'name': 'feature_extraction'
}
},
{
'primitive': {
'name': 'model_training'
}
}
]
}
ARGS = {
'pipeline': pipeline
}
- 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 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
|
| extract_scores |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_powerset_analysis.py code served (permissive licence) · get_code("2bdd440663e3b6c7") How it ranRan 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 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 torch.nn as nn
torch.manual_seed(0)
# The function expects pipelines to be a list of dicts
# Each dict should have a 'scores' key that maps to a list of dicts
# Each score dict should have a 'value' key
pipelines = [
{
'scores': [
{'value': 0.85}
]
},
{
'scores': [
{'value': 0.92}
]
},
{
'scores': [
{'value': 0.78}
]
}
]
ARGS = {
'pipelines': pipelines
}
- 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 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
|
| find_ensemble_weights |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_import_autosklearn.py code served (permissive licence) · get_code("78e46d80267263a0") How it ranRan 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 (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
class MockConfig:
def __init__(self, config_dict):
self._dict = config_dict
def get_dictionary(self):
return self._dict
class MockPipeline:
def __init__(self, config_dict):
self.config = MockConfig(config_dict)
# Create some sample parameters (can be any hashable objects)
param1 = {"layer": "conv1", "param": "weight"}
param2 = {"layer": "conv2", "param": "bias"}
param3 = {"layer": "fc", "param": "weight"}
all_params = [param1, param2, param3]
# Create models_with_weights list containing (weight, pipeline) tuples
pipeline1 = MockPipeline({"layer": "conv1", "param": "weight"})
pipeline2 = MockPipeline({"layer": "fc", "param": "weight"})
models_with_weights = [
(0.5, pipeline1),
(0.3, pipeline2),
]
ARGS = {
"all_params": all_params,
"models_with_weights": models_with_weights,
}
- 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 float, shape (3,) — shape (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
|
| find_metric_name |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_import_autosklearn.py code served (permissive licence) · get_code("af652d3f85cb2cd0") How it ranRan 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.
class MockAutoML:
def sprint_statistics(self):
return """
Some statistics here
Metric: AUC
Other info: value
"""
automl = MockAutoML()
ARGS = {
'automl': automl
}
- 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
|
| find_pipeline_digest |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_helpers.py code served (permissive licence) · get_code("02ed464496dd4171") How it ranRan 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 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
# Construct valid arguments for find_pipeline_digest
# The function expects:
# 1. pipelines: a list of dicts, each containing a 'pipeline_digest' key
# 2. digest: a single value or a list of values to search for
pipelines = [
{'pipeline_digest': 'digest_a', 'name': 'pipeline_1'},
{'pipeline_digest': 'digest_b', 'name': 'pipeline_2'},
{'pipeline_digest': 'digest_c', 'name': 'pipeline_3'},
{'pipeline_digest': 'digest_a', 'name': 'pipeline_4'},
]
digest = 'digest_a'
ARGS = {
'pipelines': pipelines,
'digest': digest,
}
- 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 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
|
| graph_data_accessor |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_graph_matching.py code served (permissive licence) · get_code("171e8b337efff784") How it ranRan 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 torch.nn as nn
torch.manual_seed(0)
# Construct the arguments for graph_data_accessor
node = {
'primitive': {
'python_path': 'some.module.path.ClassA',
'name': 'node_primitive_name'
},
'hyperparams': {
'learning_rate': 0.001,
'batch_size': 32,
'hidden_dim': 64
}
}
graph_name = 'my_graph'
ARGS = {
'node': node,
'graph_name': graph_name
}
- 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 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
|
| id_generator |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_plot_pipeline_node_link.py code served (permissive licence) · get_code("9e6f0e878723c786") How it ranRan 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 string
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# The function id_generator takes one optional parameter: size
# It generates a random string of uppercase ASCII letters of specified length
# The default size is 15, but we can pass any integer value
ARGS = {
"size": 15
}
- 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 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
|
| import_autosklearn |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_import_autosklearn.py code served (permissive licence) · get_code("bbed82fca7a991d2") How it ranRan 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 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 numpy as np
class MockAutoML:
"""Mock AutoML object that simulates auto-sklearn behavior"""
def __init__(self):
# Create mock cv_results_ with typical structure
self.cv_results_ = {
'params': [
{
'balancing:strategy': 'none',
'data_preprocessing:__choice__': 'data_preprocessing_choice_0',
'feature_preprocessor:__choice__': 'feature_preprocessor_choice_0',
'feature_preprocessor:polynomial:degree': 2,
'classifier:__choice__': 'classifier_choice_0',
'classifier:random_forest:n_estimators': 100,
},
{
'balancing:strategy': 'weighting',
'data_preprocessing:__choice__': 'data_preprocessing_choice_1',
'feature_preprocessor:__choice__': 'feature_preprocessor_choice_1',
'feature_preprocessor:pca:n_components': 5,
'classifier:__choice__': 'classifier_choice_1',
'classifier:svm:C': 1.0,
}
],
'mean_test_score': np.array([0.85, 0.90]),
'mean_fit_time': np.array([1.5, 2.3])
}
self._models_with_weights = [
(0.6, MockPipeline({'balancing:strategy': 'none', 'data_preprocessing:__choice__': 'data_preprocessing_choice_0', 'feature_preprocessor:__choice__': 'feature_preprocessor_choice_0', 'feature_preprocessor:polynomial:degree': 2, 'classifier:__choice__': 'classifier_choice_0', 'classifier:random_forest:n_estimators': 100})),
(0.4, MockPipeline({'balancing:strategy': 'weighting', 'data_preprocessing:__choice__': 'data_preprocessing_choice_1', 'feature_preprocessor:__choice__': 'feature_preprocessor_choice_1', 'feature_preprocessor:pca:n_components': 5, 'classifier:__choice__': 'classifier_choice_1', 'classifier:svm:C': 1.0}))
]
def sprint_statistics(self):
return "Some Statistics\nMetric: accuracy\nOther info"
def get_models_with_weights(self):
return self._models_with_weights
class MockPipeline:
"""Mock Pipeline object"""
def __init__(self, config_dict):
self.config = MockConfig(config_dict)
class MockConfig:
"""Mock Config object"""
def __init__(self, config_dict):
self._dict = config_dict
def get_dictionary(self):
return self._dict
ARGS = {
'automl': MockAutoML(),
'source': 'auto-sklearn'
}
- 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 list, ndim 1, 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
|
| merge_pipeline_files |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/pipeline_merge.py code served (permissive licence) · get_code("cdf74ce85a1cf951") How it ranRan 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 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 json
import tempfile
import os
# Create temporary files with valid JSON data matching the function's expectations
temp_dir = tempfile.mkdtemp()
pipelines_file = os.path.join(temp_dir, 'pipelines.jsonl')
pipeline_runs_file = os.path.join(temp_dir, 'pipeline_runs.jsonl')
# Write pipelines file
with open(pipelines_file, 'w', encoding='utf8') as f:
pipeline1 = {
'digest': 'digest_1',
'id': 'pipeline_1',
'source': 'source_1',
'created': '2023-01-01',
'inputs': [{'name': 'input_1', 'type': 'table'}],
'outputs': [{'name': 'output_1', 'type': 'table'}],
'steps': [{'step_id': 0, 'primitive': 'primitive_1'}]
}
f.write(json.dumps(pipeline1) + '\n')
pipeline2 = {
'digest': 'digest_2',
'id': 'pipeline_2',
'source': 'source_2',
'created': '2023-01-02',
'inputs': [{'name': 'input_2', 'type': 'table'}],
'outputs': [{'name': 'output_2', 'type': 'table'}],
'steps': [{'step_id': 0, 'primitive': 'primitive_2'}]
}
f.write(json.dumps(pipeline2) + '\n')
# Write pipeline runs file
with open(pipeline_runs_file, 'w', encoding='utf8') as f:
run1 = {
'pipeline': {'digest': 'digest_1'},
'run': {
'phase': 'PRODUCE',
'results': {'scores': [0.95]}
},
'problem': 'problem_1',
'start': '2023-01-01T10:00:00',
'end': '2023-01-01T10:05:00'
}
f.write(json.dumps(run1) + '\n')
run2 = {
'pipeline': {'digest': 'digest_2'},
'run': {
'phase': 'PRODUCE',
'results': {'scores': [0.87]}
},
'problem': 'problem_2',
'start': '2023-01-02T10:00:00',
'end': '2023-01-02T10:05:00'
}
f.write(json.dumps(run2) + '\n')
ARGS = {
'pipelines_file': pipelines_file,
'pipeline_runs_file': pipeline_runs_file,
'n': -1,
'verbose': False
}
- 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 list, ndim 1, 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
|
| node_type |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_similarity_flooding.py code served (permissive licence) · get_code("e257df5f0fbcb877") How it ranRan 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 networkx as nx
torch.manual_seed(0)
# Create a simple directed graph with networkx
g = nx.DiGraph()
# Add a node with the required 'data' structure
# The function accesses node['data'][0]['python_path']
node_data = {
'python_path': 'module.submodule.NodeType'
}
g.add_node('node_0', data=[node_data])
# Also add another node with a shorter path
node_data_2 = {
'python_path': 'simple.path'
}
g.add_node('node_1', data=[node_data_2])
ARGS = {
'g': g,
'node': 'node_0'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- networkx, 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
|
| pipeline_to_graph |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_graph_matching.py code served (permissive licence) · get_code("5d81e8b2d80be745") How it ranRan 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 DiGraph. 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 networkx as nx
ARGS = {
'pipeline': {
'pipeline_digest': 'test_pipeline_v1',
'steps': [
{
'primitive': {
'python_path': 'sklearn.preprocessing.StandardScaler',
'name': 'StandardScaler'
},
'hyperparams': {
'with_mean': True,
'with_std': True
},
'arguments': {
'inputs': {
'data': 'inputs.0'
}
}
},
{
'primitive': {
'python_path': 'sklearn.linear_model.LogisticRegression',
'name': 'LogisticRegression'
},
'hyperparams': {
'max_iter': 100
},
'arguments': {
'inputs': {
'data': 'steps.0'
}
}
}
],
'outputs': [
{
'data': 'steps.1'
}
]
},
'name': 'my_test_pipeline'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- networkx — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DiGraph — a DiGraph output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DiGraph output the recorded ndim 1 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
|
| python_path_similarity |
Ran ran on a synthesized input |
VIDA-NYU/PipelineVis/PipelineProfiler/_graph_matching.py code served (permissive licence) · get_code("64cc10732a5bf54b") How it ranRan 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 torch
# The function takes two python_path strings and compares them
# It checks equality, splits by '.', and compares elements at index 2
ARGS = {
'python_path1': 'my.module.submodule.function',
'python_path2': 'my.module.submodule.other_function'
}
- 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 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
|
| comm_merge_graphs |
Not yet run unverified (harvested, no recorded run) |
VIDA-NYU/PipelineVis/PipelineProfiler/_plot_pipeline_matrix.py code served (permissive licence) · get_code("fd412c5826f4338f") How it ran |
| comm_powerset_analysis |
Not yet run unverified (harvested, no recorded run) |
VIDA-NYU/PipelineVis/PipelineProfiler/_plot_pipeline_matrix.py code served (permissive licence) · get_code("ce3a9407ef5f2b82") How it ran |
| make_html |
Not yet run unverified (harvested, no recorded run) |
VIDA-NYU/PipelineVis/PipelineProfiler/_plot_pipeline_node_link.py code served (permissive licence) · get_code("f03844004cdb90bc") How it ran |
| setup_comm_colab |
Not yet run unverified (harvested, no recorded run) |
VIDA-NYU/PipelineVis/PipelineProfiler/_comm_api.py code served (permissive licence) · get_code("1996a25026aaf84a") How it ran |