| compute_cosine_similarity |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/CosineSim.py code served (permissive licence) · get_code("fe86c613fc8212a2") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small feature arrays
# real_features: shape (N, D) - let's use (2, 4) for 2 real samples, 4 dimensions
real_features = np.random.randn(2, 4).astype(np.float64)
# gen_features: shape (M, D) - let's use (3, 4) for 3 generated samples, 4 dimensions
gen_features = np.random.randn(3, 4).astype(np.float64)
# aggregate parameter - test with 'mean_vectors' mode
aggregate = 'mean_vectors'
# axis parameter - optional, set to None (default)
axis = None
ARGS = {
'real_features': real_features,
'gen_features': gen_features,
'aggregate': aggregate,
'axis': axis
}
- 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
|
| compute_cosine_similarity_per_sample |
Ran ran, violated the contract we drafted |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/CosineSim.py code served (permissive licence) · get_code("570e5a95e156caf1") 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
# Set random seeds for reproducibility
np.random.seed(0)
# Create small feature matrices
# real_features: (N, D) shape - N samples, D dimensions
# gen_features: (N, D) shape - must match real_features shape
N = 2 # number of samples
D = 4 # feature dimension
# Generate random feature vectors
real_features = np.random.randn(N, D).astype(np.float64)
gen_features = np.random.randn(N, D).astype(np.float64)
ARGS = {
"real_features": real_features,
"gen_features": gen_features,
}
- 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
|
| compute_entropy_diversity |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/Entropy.py code served (permissive licence) · get_code("954d5301fd9a4c0e") 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
# Construct valid arguments for compute_entropy_diversity
gen_features = np.random.randn(8, 5) # (M=8 samples, D=5 dimensions)
n_bins = 30
ARGS = {
"gen_features": gen_features,
"n_bins": n_bins,
}
- 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
|
| compute_entropy_stats |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/Entropy.py code served (permissive licence) · get_code("c708cdcc27605036") 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, 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
# Set random seeds for reproducibility
np.random.seed(0)
# Create small sample feature arrays
# real_features: shape (N, D) where N=5 samples, D=4 dimensions
real_features = np.random.randn(5, 4).astype(np.float64)
# gen_features: shape (M, D) where M=3 samples, D=4 dimensions
gen_features = np.random.randn(3, 4).astype(np.float64)
# Number of bins for histogram
n_bins = 10
ARGS = {
"real_features": real_features,
"gen_features": gen_features,
"n_bins": n_bins,
}
- 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, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_fid |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/FID.py code served (permissive licence) · get_code("efde5861d5b96c8c") 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
np.random.seed(0)
# Create small feature arrays for real and generated data
# Using distinct dimensions: 8 samples, 4 features
real_features = np.random.randn(8, 4).astype(np.float32)
gen_features = np.random.randn(8, 4).astype(np.float32)
ARGS = {
"real_features": real_features,
"gen_features": gen_features,
"eps": 1e-06,
"normalize": True,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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
|
| compute_inception_score |
Ran ran; our contract draft was wrong, not the code |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/IS.py code served (permissive licence) · get_code("39e062653ef7d4d5") 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, 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
# Set random seeds for reproducibility
np.random.seed(42)
# Create small feature matrices
# real_features: (N, D) - 8 real samples with 4 features
real_features = np.random.randn(8, 4).astype(np.float32)
# gen_features: (M, D) - 6 generated samples with 4 features
gen_features = np.random.randn(6, 4).astype(np.float32)
# real_labels: (N,) - class labels for real samples, in range [0, num_classes-1]
real_labels = np.array([0, 1, 0, 1, 0, 1, 0, 1], dtype=np.int32)
# num_classes: 2 classes
num_classes = 2
# n_splits: split generated samples into 2 splits for averaging
n_splits = 2
# random_state: seed for reproducibility
random_state = 42
ARGS = {
"real_features": real_features,
"gen_features": gen_features,
"real_labels": real_labels,
"num_classes": num_classes,
"n_splits": n_splits,
"random_state": random_state,
}
- 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, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_inception_score_simple |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/IS.py code served (permissive licence) · get_code("97f0c97ed890a815") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small generated features: shape (M, D) = (12, 8)
# M=12 samples, D=8 dimensions
gen_features = np.random.randn(12, 8).astype(np.float32)
# real_labels is optional and unused in the function
real_labels = None
# num_classes is optional and unused in the function
num_classes = None
# n_bins for histogram discretization
n_bins = 10
ARGS = {
"gen_features": gen_features,
"real_labels": real_labels,
"num_classes": num_classes,
"n_bins": n_bins,
}
- 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
|
| compute_jaccard_similarity |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/JaccardSim.py code served (permissive licence) · get_code("a06161606ce640b5") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create sample feature arrays
# real_features: shape (N, D) where N=5 samples, D=4 features
real_features = np.random.randn(5, 4) * 10 + 50
# gen_features: shape (M, D) where M=3 samples, D=4 features
gen_features = np.random.randn(3, 4) * 10 + 50
ARGS = {
'real_features': real_features,
'gen_features': gen_features,
'binarize': 'median',
'threshold': None,
'per_feature': False,
}
- 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
|
| compute_jaccard_similarity_1to1 |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/JaccardSim.py code served (permissive licence) · get_code("956dc76653b8ab1a") 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
np.random.seed(0)
# Create small feature matrices: (N=2, D=4)
# Real features: 2 samples, 4 dimensions
real_features = np.array([
[0.1, 0.5, 0.3, 0.8],
[0.2, 0.6, 0.4, 0.7]
], dtype=np.float64)
# Generated features: same shape
gen_features = np.array([
[0.15, 0.55, 0.35, 0.75],
[0.25, 0.65, 0.45, 0.72]
], dtype=np.float64)
ARGS = {
'real_features': real_features,
'gen_features': gen_features,
'binarize': 'median'
}
- 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
|
| compute_mmd |
Ran ran, violated the contract we drafted |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/MMD.py code served (permissive licence) · get_code("767ba4732682b723") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small sample data for real and generated distributions
# Shape: (n_samples, n_features)
real = np.random.randn(2, 4).astype(np.float32)
gen = np.random.randn(3, 4).astype(np.float32)
ARGS = {
"real": real,
"gen": gen,
"kernel": "rbf",
"gamma": None,
}
- 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
|
| compute_prediction_entropy |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/Entropy.py code served (permissive licence) · get_code("8d63492121e4097e") 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, 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small synthetic data
N = 8 # number of real samples
M = 6 # number of generated samples
D = 4 # feature dimension
num_classes = 3
# Real features: (N, D)
real_features = np.random.randn(N, D).astype(np.float32)
# Generated features: (M, D)
gen_features = np.random.randn(M, D).astype(np.float32)
# Real labels: (N,) with values in [0, num_classes)
real_labels = np.array([0, 1, 2, 0, 1, 2, 0, 1], dtype=np.int32)
ARGS = {
"real_features": real_features,
"gen_features": gen_features,
"real_labels": real_labels,
"num_classes": num_classes,
}
- 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, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| compute_snr_eeg |
Ran ran; our contract draft was wrong, not the code |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/SNR.py code served (permissive licence) · get_code("532e1f1eee53c9d7") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create sample EEG data
# Shape: (N, C, T) where N=batch, C=channels, T=time
real_eeg = np.random.randn(2, 4, 8).astype(np.float64)
gen_eeg = np.random.randn(2, 4, 8).astype(np.float64)
ARGS = {
"real_eeg": real_eeg,
"gen_eeg": gen_eeg,
"per_channel": False,
"axis_time": -1,
}
- 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
|
| compute_snr_features |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/SNR.py code served (permissive licence) · get_code("b52800d247feccae") 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 small feature arrays
np.random.seed(0)
# Real features: 5 samples, 4 dimensions
real_features = np.random.randn(5, 4).astype(np.float64)
# Generated features: 3 samples, 4 dimensions
gen_features = np.random.randn(3, 4).astype(np.float64)
# Method parameter
method = 'mean_std'
ARGS = {
'real_features': real_features,
'gen_features': gen_features,
'method': method,
}
- 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
|
| compute_snr_simple |
Ran ran; our contract draft was wrong, not the code |
wzwvv/DG4BCI/Synthetic_Data_Evaluation/SNR.py code served (permissive licence) · get_code("7f4a0c696d170ab7") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small numpy arrays for real and generated features
# Shape: (batch_size, feature_dim)
real_features = np.random.randn(2, 4).astype(np.float64)
gen_features = np.random.randn(2, 4).astype(np.float64)
# Small epsilon value for numerical stability
eps = 1e-08
ARGS = {
"real_features": real_features,
"gen_features": gen_features,
"eps": eps,
}
- 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
|
| data_alignment_returnref |
Ran ran, honoured the contract we drafted |
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/CR.py code served (permissive licence) · get_code("948ad027c94c7d52") 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 scipy.linalg import fractional_matrix_power
# Create a small EEG data array
# Shape: (batch_size, channels, time_samples)
# Using distinct dimensions: 2 samples, 4 channels, 5 time points
np.random.seed(0)
x = np.random.randn(2, 4, 5)
ARGS = {
"x": x
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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
|
| data_aug |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/Baselines.py code served (permissive licence) · get_code("a8082675d383dd03") 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 scipy.signal import hilbert
np.random.seed(0)
# Create sample data with shape (num_samples, time_steps, num_channels)
# Using small dimensions: 2 samples, 128 time steps, 22 channels
num_samples = 2
time_steps = 128
num_channels = 22
data = np.random.randn(num_samples, time_steps, num_channels).astype(np.float32)
# Create labels - all non-negative so they pass the if labels[i] >= 0 check
labels = np.array([0, 1], dtype=np.int32)
# size parameter should match the time_steps dimension
size = time_steps
# flag_aug is a tuple/list of 4 boolean flags: [mult_flag, noise_flag, neg_flag, freq_mod_flag]
flag_aug = [True, True, True, True]
ARGS = {
'data': data,
'labels': labels,
'size': size,
'flag_aug': flag_aug
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, scipy — 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
|
| data_mult_f |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/Baselines.py code served (permissive licence) · get_code("191cd19232b470c3") 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
# Construct small valid data and labels
# data should be indexable and support multiplication
# labels should be indexable and support comparison with >= 0
batch_size = 2
size = 4
n_channels = 22
# Create data: shape (batch_size, size, n_channels) or flat that can be reshaped
# The function multiplies data[i] by a scalar and reshapes at the end
# So data[i] should be something that when multiplied gives a numeric array
data = np.random.randn(batch_size, size, n_channels).astype(np.float32)
# Create labels: some >= 0 (will be kept), some < 0 (will be filtered out)
labels = np.array([0.5, -1.0]) # First will pass filter, second will not
ARGS = {
"data": data,
"labels": labels,
"size": size,
"n_channels": n_channels,
}
- 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
|
| data_noise_f |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/Baselines.py code served (permissive licence) · get_code("c5a2c7a7f9df455b") 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
# Set random seed for reproducibility
np.random.seed(0)
# Create small sample data
# data should be a list of 2D arrays (time steps x channels)
data = [
np.random.randn(10, 22), # 10 time steps, 22 channels
np.random.randn(10, 22), # 10 time steps, 22 channels
]
# Create labels (all non-negative to pass the if condition)
labels = np.array([0, 1])
# size parameter should match the first dimension after reshape
# The function reshapes to [-1, size, n_channels]
# With 2 samples of shape (10, 22), flattened is 2*10*22 = 440 elements
# Reshaped to [-1, size, 22] means -1 = 440 / (size * 22)
# If size = 10, then -1 = 440 / (10 * 22) = 2
size = 10
# n_channels is the number of channels per time step
n_channels = 22
ARGS = {
"data": data,
"labels": labels,
"size": size,
"n_channels": n_channels,
}
- 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
|