| balance_classes |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/classify.py code served (permissive licence) · get_code("4e66903f7714773f") 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
import logging
logging.basicConfig(level=logging.INFO)
# Create sample data for different classes
# Class 0: 5 samples of 4 features each
X_class_0 = np.random.randn(5, 4).astype(np.float32)
# Class 1: 3 samples of 4 features each (smallest class)
X_class_1 = np.random.randn(3, 4).astype(np.float32)
# Class 2: 7 samples of 4 features each
X_class_2 = np.random.randn(7, 4).astype(np.float32)
ARGS = {
"X_list": [X_class_0, X_class_1, X_class_2],
"class_names": ["class_A", "class_B", "class_C"],
"random_state": 42,
}
- 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
|
| build_features |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
ramiluisto/CuriousSwirl/semsim/classify.py code served (permissive licence) · get_code("65507ab8bdad9e9f") 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 2, dtype family float, 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
# Create small embedding pairs
emb1_1 = np.random.randn(4) # embedding of dim 4
emb1_2 = np.random.randn(4)
emb2_1 = np.random.randn(4)
emb2_2 = np.random.randn(4)
emb_pairs = [
(emb1_1, emb1_2),
(emb2_1, emb2_2),
]
ARGS = {
'emb_pairs': emb_pairs,
'input_type': 'difference',
}
- 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 float, 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
|
| build_projection_params |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/projection_cache.py code served (permissive licence) · get_code("aea8a7d36b40146f") 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 numpy as np
from typing import List
torch.manual_seed(0)
ARGS = {
'pair_types': ['type_a', 'type_b', 'type_c'],
'symmetrize': True,
'standardize': False,
'metric': 'euclidean',
}
- 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
|
| compute_pca_projection |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
ramiluisto/CuriousSwirl/semsim/projections.py code served (permissive licence) · get_code("51e4bf7eff968db9") 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
import logging
logging.basicConfig(level=logging.INFO)
# Create a small feature matrix with distinct dimensions
# n_samples=7, n_features=5 (more features than components we'll request)
X = np.random.randn(7, 5).astype(np.float32)
ARGS = {
"X": X,
"max_components": 4,
"n_components": 2,
}
- 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
|
| cosine_similarity |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/stats.py code served (permissive licence) · get_code("3500710b647d99ab") 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 numpy as np
# Create two sample numpy arrays for the cosine similarity function
v1 = np.array([1.0, 2.0, 3.0, 4.0])
v2 = np.array([2.0, 3.0, 4.0, 5.0])
ARGS = {
"v1": v1,
"v2": v2,
}
- 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 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
|
| dot_product |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/stats.py code served (permissive licence) · get_code("9a9338b265d08fe3") 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 numpy as np
# Create two small numpy vectors for the dot product
v1 = np.array([1.0, 2.0, 3.0, 4.0])
v2 = np.array([5.0, 6.0, 7.0, 8.0])
ARGS = {
"v1": v1,
"v2": v2,
}
- 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 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
|
| euclidean_distance |
Ran ran, honoured the contract we drafted |
ramiluisto/CuriousSwirl/semsim/stats.py code served (permissive licence) · get_code("45e2b883e4e52baa") 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 numpy as np
# Create two small numpy arrays of different sizes to test the euclidean distance function
v1 = np.array([1.0, 2.0, 3.0, 4.0])
v2 = np.array([5.0, 6.0, 7.0, 8.0])
ARGS = {
"v1": v1,
"v2": v2,
}
- 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 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
|
| extract_transformer_embeddings |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/embeddings.py code served (permissive licence) · get_code("db18cbb63ad64fdb") 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
import numpy as np
from typing import Set, Dict
import logging
torch.manual_seed(0)
logging.basicConfig(level=logging.INFO)
# Create a minimal mock tokenizer
class MockTokenizer:
def __init__(self):
self.vocab_size = 1000
def encode(self, text, add_special_tokens=False):
# Simple mock: return consistent token ids based on text hash
# Ensure single-token variants map to single ids
hash_val = hash(text) % (self.vocab_size - 1)
return [hash_val]
# Create a minimal transformer model with embeddings
class MockTransformer(nn.Module):
def __init__(self):
super().__init__()
self.embeddings = nn.Module()
# Add word_embeddings as a simple embedding layer
self.embeddings.word_embeddings = nn.Embedding(1000, 16)
def eval(self):
return self
def to(self, device):
return super().to(device)
# Mock AutoModel and AutoTokenizer
class MockAutoModel:
@staticmethod
def from_pretrained(model_name):
return MockTransformer()
class MockAutoTokenizer:
@staticmethod
def from_pretrained(model_name):
return MockTokenizer()
# Patch transformers module before import in function
import sys
class MockTransformersModule:
AutoModel = MockAutoModel
AutoTokenizer = MockAutoTokenizer
sys.modules['transformers'] = MockTransformersModule()
# Create test vocabulary
vocabulary = {'hello', 'world', 'test', 'python', 'embedding'}
ARGS = {
'model_name': 'bert-base-uncased',
'vocabulary': vocabulary,
'device': 'cpu',
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch, transformers — 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
|
| generate_antonym_pairs |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/pairs.py code served (permissive licence) · get_code("733c302dd47abcb2") 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 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 logging
from typing import Dict, List, Set, Tuple
import numpy as np
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Create sample data
stuttgart_pairs = [
("big", "small"),
("hot", "cold"),
("fast", "slow"),
]
curated_pairs = [
("happy", "sad"),
("light", "dark"),
("big", "tiny"), # Will be deduplicated with stuttgart pair
]
# Create embeddings dictionary with numpy arrays for words that appear in pairs
embeddings = {
"big": np.random.randn(4),
"small": np.random.randn(4),
"hot": np.random.randn(4),
"cold": np.random.randn(4),
"fast": np.random.randn(4),
"slow": np.random.randn(4),
"happy": np.random.randn(4),
"sad": np.random.randn(4),
"light": np.random.randn(4),
"dark": np.random.randn(4),
"tiny": np.random.randn(4),
}
ARGS = {
"stuttgart_pairs": stuttgart_pairs,
"curated_pairs": curated_pairs,
"embeddings": embeddings,
}
- 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 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
|
| generate_shuffled_pairs |
Ran ran on a synthesized input |
ramiluisto/CuriousSwirl/semsim/pairs.py code served (permissive licence) · get_code("f5c3c779c57bee35") 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 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 random
from typing import Dict, List, Set, Tuple
# Construct valid arguments for generate_shuffled_pairs
# original_pairs: A list of (word1, word2) tuples representing semantic pairs
original_pairs = [
("cat", "dog"),
("car", "bicycle"),
("happy", "sad"),
("big", "small"),
]
# semantic_exclusion_set: Set of canonical (sorted) pair tuples to exclude
# These are pairs we don't want to appear in the shuffled output
semantic_exclusion_set = {
("cat", "dog"),
("big", "small"),
}
# random_state: Random seed for reproducibility
random_state = 42
ARGS = {
"original_pairs": original_pairs,
"semantic_exclusion_set": semantic_exclusion_set,
"random_state": random_state,
}
- 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 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
|
| generate_synonym_pairs |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/pairs.py code served (permissive licence) · get_code("524abf9bd354578b") 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 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 logging
import numpy as np
from typing import Dict, List, Tuple
logging.basicConfig(level=logging.INFO)
# Define the PairList type
PairList = List[Tuple[str, str]]
# Create sample Stuttgart pairs - some with embeddings, some without
stuttgart_pairs = [
("cat", "feline"),
("dog", "canine"),
("happy", "joyful"),
("big", "large"),
("unknown_word_1", "unknown_word_2"),
("small", "tiny"),
]
# Create embeddings dict with numpy arrays
# Only include embeddings for some of the words
embeddings = {
"cat": np.random.randn(4),
"feline": np.random.randn(4),
"dog": np.random.randn(4),
"canine": np.random.randn(4),
"happy": np.random.randn(4),
"joyful": np.random.randn(4),
"big": np.random.randn(4),
"large": np.random.randn(4),
"small": np.random.randn(4),
"tiny": np.random.randn(4),
# Note: "unknown_word_1" and "unknown_word_2" are NOT in embeddings
}
ARGS = {
"stuttgart_pairs": stuttgart_pairs,
"embeddings": embeddings,
}
- 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 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_nouns |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/data.py code served (permissive licence) · get_code("b90f750b418d59aa") 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 set. 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 pandas as pd
# Create a sample DataFrame with the structure expected by get_nouns
# The function looks for rows where 'pos' == 'nouns' and extracts 'word1' and 'word2'
df = pd.DataFrame({
'pos': ['nouns', 'nouns', 'verbs', 'nouns', 'adjectives'],
'word1': ['cat', 'dog', 'run', 'bird', 'happy'],
'word2': ['feline', 'canine', 'sprint', 'avian', 'joyful']
})
ARGS = {
'df': df
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type set — a set output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a set 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_vocabulary |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/data.py code served (permissive licence) · get_code("f60cc27077f1980b") 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 set. 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 pandas as pd
import torch
torch.manual_seed(0)
# Create a simple DataFrame with 'word1' and 'word2' columns
df = pd.DataFrame({
'word1': ['hello', 'world', 'foo'],
'word2': ['test', 'example', 'bar']
})
ARGS = {
'df': df
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type set — a set output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a set 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
|
| load_embeddings |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/embeddings.py code served (permissive licence) · get_code("e298f4b865e41113") 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 tempfile
import pickle
from pathlib import Path
import numpy as np
# Create a temporary directory for test files
tmpdir = Path(tempfile.gettempdir())
# Create a pickle file with embeddings
pickle_path = tmpdir / "test_embeddings.pkl"
embeddings_dict = {
"hello": np.array([1.0, 2.0, 3.0, 4.0]),
"world": np.array([5.0, 6.0, 7.0, 8.0]),
"test": np.array([9.0, 10.0, 11.0, 12.0])
}
with open(pickle_path, 'wb') as f:
pickle.dump(embeddings_dict, f)
ARGS = {
"path": pickle_path
}
- 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 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
|
| load_stuttgart |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/data.py code served (permissive licence) · get_code("6f9a74ca00952c93") 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 DataFrame. 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 tempfile
from pathlib import Path
import pandas as pd
# Create a temporary directory with mock Stuttgart dataset files
tmpdir = tempfile.TemporaryDirectory()
tmppath = Path(tmpdir.name)
# Create mock Stuttgart dataset files
STUTTGART_FILES = ['adjectives.train', 'adjectives.test', 'adjectives.val', 'nouns.train', 'nouns.test', 'nouns.val', 'verbs.train', 'verbs.test', 'verbs.val']
for filename in STUTTGART_FILES:
filepath = tmppath / filename
with filepath.open('w', encoding='utf-8') as f:
f.write("happy\tsad\t1\n")
f.write("big\tsmall\t1\n")
f.write("fast\tquick\t0\n")
ARGS = {
'stuttgart_dir': tmppath
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
|
| plot_confusion_matrix |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
ramiluisto/CuriousSwirl/semsim/plots.py code served (permissive licence) · get_code("2523a48b4c15f71f") 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 Figure. 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
from pathlib import Path
from typing import Dict, List, Optional, Union
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Create a small confusion matrix (4x4 for 4 classes)
cm = np.array([
[45, 5, 2, 1],
[3, 48, 4, 2],
[2, 6, 42, 3],
[1, 1, 2, 51]
], dtype=np.int32)
# Define class names
class_names = ['Class_A', 'Class_B', 'Class_C', 'Class_D']
# Define title
title = 'Test Confusion Matrix'
# Define save path (using a temporary path, but we won't actually save)
save_path = Path('/tmp/confusion_matrix.png')
# Define figsize
figsize = (10, 8)
# Define dpi
dpi = 100
ARGS = {
'cm': cm,
'class_names': class_names,
'title': title,
'save_path': save_path,
'figsize': figsize,
'dpi': dpi
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, seaborn — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Figure — a Figure output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Figure 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
|
| plot_metric_distributions |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
ramiluisto/CuriousSwirl/semsim/plots.py code served (permissive licence) · get_code("28c4a8b9ae88c062") 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 Figure. 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
from pathlib import Path
import numpy as np
import matplotlib
matplotlib.use('Agg') # Non-interactive backend
import matplotlib.pyplot as plt
logging.basicConfig(level=logging.INFO)
# Create sample metric data for different pair types
metrics_by_type = {
'type_A': np.random.randn(15),
'type_B': np.random.randn(20),
'type_C': np.random.randn(18),
}
metric_name = 'correlation_score'
title = 'Metric Distribution Across Pair Types'
save_path = None # No file I/O in sandbox
figsize = (10, 6)
dpi = 300
ARGS = {
'metrics_by_type': metrics_by_type,
'metric_name': metric_name,
'title': title,
'save_path': save_path,
'figsize': figsize,
'dpi': dpi,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Figure — a Figure output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Figure 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
|
| plot_pvalue_heatmap |
Ran ran; our contract draft was wrong, not the code |
ramiluisto/CuriousSwirl/semsim/plots.py code served (permissive licence) · get_code("720477544f913473") 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 Figure. 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
from pathlib import Path
from typing import Dict, List, Optional, Union
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
# Set up logging
logging.basicConfig(level=logging.INFO)
# Create valid arguments for plot_pvalue_heatmap
pvalues = {
"comparison_A": {
"metric_1": 0.01,
"metric_2": 0.03,
"metric_3": 0.001,
},
"comparison_B": {
"metric_1": 0.02,
"metric_2": 0.015,
"metric_3": 0.04,
},
"comparison_C": {
"metric_1": 0.005,
"metric_2": 0.025,
"metric_3": 0.012,
},
}
title = "p-value Heatmap"
save_path = None # No file I/O
figsize = (10, 8)
dpi = 300
ARGS = {
"pvalues": pvalues,
"title": title,
"save_path": save_path,
"figsize": figsize,
"dpi": dpi,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy, seaborn — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Figure — a Figure output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Figure 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
|
| symmetrize_features |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
ramiluisto/CuriousSwirl/semsim/classify.py code served (permissive licence) · get_code("b06f15870f2100a1") 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 2, dtype family float, shape (4, 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
# Create a small feature matrix for testing
# Using shape (2, 4) - 2 samples, 4 features
X = np.array([
[1.0, 2.0, 3.0, 4.0],
[5.0, 6.0, 7.0, 8.0]
], dtype=np.float32)
ARGS = {
'X': X,
'base_input_type': 'difference'
}
- 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 float, shape (4, 4) — shape (4, 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
|
| compute_tsne_projection |
Not yet run unverified (harvested, no recorded run) |
ramiluisto/CuriousSwirl/semsim/projections.py code served (permissive licence) · get_code("8c2201a9c54f1361") How it ran |
| compute_umap_projection |
Not yet run unverified (harvested, no recorded run) |
ramiluisto/CuriousSwirl/semsim/projections.py code served (permissive licence) · get_code("4776fba74086339d") How it ran |
| extract_word2vec_embeddings |
Not yet run unverified (harvested, no recorded run) |
ramiluisto/CuriousSwirl/semsim/embeddings.py code served (permissive licence) · get_code("0d46a4f5b229b35f") How it ran |
| get_embedding_path |
Not yet run unverified (harvested, no recorded run) |
ramiluisto/CuriousSwirl/config.py code served (permissive licence) · get_code("f087285272edbb72") How it ran |
| get_model_slug |
Not yet run unverified (harvested, no recorded run) |
ramiluisto/CuriousSwirl/config.py code served (permissive licence) · get_code("d0ad9ca728f04022") How it ran |
| get_pair_path |
Not yet run unverified (harvested, no recorded run) |
ramiluisto/CuriousSwirl/config.py code served (permissive licence) · get_code("39d62c2346fbb8ed") How it ran |