| affine |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/models/modulo_net/normalization.py code served (permissive licence) · get_code("48b2a11244c8eec9") 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 Tensor, 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 torch
import numpy as np
torch.manual_seed(0)
# Create tiny tensors
x = torch.randn(2, 4)
gain = torch.randn(2, 4)
bias = 0
ARGS = {
"x": x,
"gain": gain,
"bias": bias,
}
- 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 Tensor, 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
|
| augment_data |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/datasets/data_augmentation.py code served (permissive licence) · get_code("8ae689bec5854251") 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 numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Create sample data with shape (batch, channels, height)
# Using distinct dimensions: batch=2, channels=4, height=3
sample_data = np.random.randn(2, 4, 3)
# Construct the data dict with a group
data = {
'group1': sample_data.copy()
}
# Construct augmentation pipeline
augmentation_pipeline = [
{
'name': 'group1',
'processing': [
{
'type': 'kill_channel',
'args': {'p': 0.5}
}
]
}
]
ARGS = {
'data': data,
'augmentation_pipeline': augmentation_pipeline
}
- 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
|
| build_consensus_hypnogram |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Dreem-Organization/dreem-learning-evaluation/evaluation.py code served (permissive licence) · get_code("918adff8add965aa") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple, 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 numpy as np
# Construct valid arguments for build_consensus_hypnogram
# The function expects ranked_hypnograms_consensus: a list of hypnograms
# Each hypnogram is a sequence of sleep stage labels (0-4, representing different stages)
# The function will add 1 to these values internally, so we use 0-4 range
# Create 3 ranked hypnograms, each with 5 epochs
# Each epoch has a sleep stage label from 0-4
hypnogram_1 = [0, 1, 2, 2, 3] # Reference hypnogram (used for tie-breaking)
hypnogram_2 = [0, 1, 2, 3, 3]
hypnogram_3 = [0, 1, 1, 2, 3]
ranked_hypnograms_consensus = [hypnogram_1, hypnogram_2, hypnogram_3]
ARGS = {
"ranked_hypnograms_consensus": ranked_hypnograms_consensus
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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 2, 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
|
| clip |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/models/modulo_net/normalization.py code served (permissive licence) · get_code("867d2c4a9b3665e3") 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 Tensor, 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 torch
torch.manual_seed(0)
# The clip function takes two parameters:
# - x: a tensor to clamp
# - value: the clamp bound (absolute value)
x = torch.randn(2, 4)
value = 0.5
ARGS = {
"x": x,
"value": value,
}
- 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 Tensor, 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
|
| cohen_kappa_custom |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/utils/scores.py code served (permissive licence) · get_code("7e53985f41c0c2e4") 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
from sklearn.metrics import cohen_kappa_score, f1_score, accuracy_score
def cohen_kappa_custom(true, pred):
labels = list(set([0, 1, 2, 3, 4]).intersection(set(true)))
return cohen_kappa_score(true, pred, labels=labels)
# Create small sample data for true and pred
# Both should be 1D arrays/lists of class labels (0-4)
true = np.array([0, 1, 2, 3, 4, 0, 1, 2])
pred = np.array([0, 1, 2, 2, 4, 0, 1, 3])
ARGS = {
"true": true,
"pred": pred
}
- 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 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_memmap_hash |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/h5_to_memmap.py code served (permissive licence) · get_code("856fb590eba3e24d") 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 hashlib
import json
# The function compute_memmap_hash takes a memmap_description parameter
# and converts it to JSON, then computes a SHA1 hash of it.
# memmap_description should be something JSON-serializable (dict, list, etc.)
memmap_description = {
"shape": [1024, 512],
"dtype": "float32",
"offset": 0,
"filename": "data.bin",
"mode": "r",
"version": 1
}
ARGS = {
"memmap_description": memmap_description
}
- 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
|
| compute_night_metrics |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Dreem-Organization/dreem-learning-evaluation/evaluation.py code served (permissive licence) · get_code("302691ee73a2e048") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned OrderedDict. 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 collections import OrderedDict
# Analyze the function: compute_night_metrics takes a hypnogram parameter
# A hypnogram is iterated over with enumerate, and each stage is compared to integers (0, 1, 2, 3, 4)
# It's a sequence of sleep stage labels
# Create a valid hypnogram - a list of integers representing sleep stages
# Stage 0 = Wake, 1 = N1, 2 = N2, 3 = N3, 4 = REM
# Need enough data to trigger the conditions in the function
# - Need at least 3 consecutive non-wake stages for 'sod' (sleep onset)
# - Need at least 10 consecutive non-wake stages for 'lps' (light period start)
hypnogram = [
0, 0, 0, # Initial wake
1, 1, 1, # N1 (3 consecutive non-wake, triggers sod at index 5)
2, 2, 2, 2, 2, 2, 2, # N2 (reaches 10 consecutive non-wake at index 12, triggers lps)
3, 3, 3, # N3
4, 4, 4, 4, # REM
0, 0, # WASO (wake after sleep onset)
2, 2, 2, # Back to N2
0, # Final wake
]
ARGS = {
'hypnogram': hypnogram
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type OrderedDict — a OrderedDict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a OrderedDict 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_soft_agreement |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
Dreem-Organization/dreem-learning-evaluation/evaluation.py code served (permissive licence) · get_code("f92cfbe72d68e6b8") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned float64, 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_soft_agreement
# The function expects:
# - hypnogram: a sequence of sleep stage labels (integers -1 to 4, representing stages 0-5 after +1)
# - hypnograms_consensus: a list of such sequences from multiple raters
# Create a single hypnogram (ground truth or reference)
# Sleep stages are typically: -1 (unknown/artifact), 0 (wake), 1 (N1), 2 (N2), 3 (N3), 4 (REM)
# After +1 indexing in the function, these map to indices 0-5
hypnogram = np.array([0, 1, 2, 2, 3, 4, 1, 0], dtype=int)
# Create multiple consensus hypnograms from different raters
# Each should be the same length as the reference hypnogram
hypnograms_consensus = [
np.array([0, 1, 2, 2, 3, 4, 1, 0], dtype=int),
np.array([0, 1, 1, 2, 3, 4, 1, 0], dtype=int),
np.array([0, 0, 2, 2, 3, 4, 2, 0], dtype=int),
]
ARGS = {
"hypnogram": hypnogram,
"hypnograms_consensus": hypnograms_consensus,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float64, 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
|
| cyclic_index_window |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/epoch_features_processing.py code served (permissive licence) · get_code("248d2cceb9938a91") 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 (5, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a small signal: 1200 samples at 40 Hz sampling frequency
# This gives us 30 windows with increment_duration=30
signal = np.random.randn(1200).astype(np.float32)
# Signal properties with sampling frequency
signal_properties = {
'fs': 40 # 40 Hz sampling frequency
}
# Define arguments for cyclic_index_window
ARGS = {
'signal': signal,
'signal_properties': signal_properties,
'increment_duration': 30,
'cycles_length': [10, 30, 60, 90, 120],
'padding_duration': 60
}
- 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 (5, 5) — shape (5, 5) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| f1_custom |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/utils/scores.py code served (permissive licence) · get_code("a377531334afcb0a") 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 float64, ndim 0, 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
# Construct valid arguments for f1_custom
# The function takes true and pred as parameters, both should be array-like
# with integer class labels from 0 to 4
# Create true labels - array with 5 classes (0-4), with different occurrences
true = np.array([0, 0, 1, 1, 1, 2, 2, 3, 4, 4])
# Create predictions - some correct, some incorrect
pred = np.array([0, 0, 1, 1, 2, 2, 3, 3, 4, 0])
ARGS = {
"true": true,
"pred": pred
}
- 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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
- 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
|
| fft |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/epoch_features_processing.py code served (permissive licence) · get_code("17f77ead9e021fe4") 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, 151) 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 signal: 2 samples, each 5 seconds at 10 Hz
# increment_duration=30 seconds would need 300 samples per chunk
# So let's make signal with 600 samples total (2 chunks of 30 seconds each at 10 Hz)
signal_frequency = 10 # Hz
increment_duration = 30 # seconds
num_samples = increment_duration * signal_frequency * 2 # 600 samples for 2 increments
signal = np.random.randn(num_samples).astype(np.float32)
# Create signal_properties dict with sampling frequency
signal_properties = {
'fs': signal_frequency
}
# Create ARGS dict with all parameters
ARGS = {
'signal': signal,
'signal_properties': signal_properties,
'padding_duration': 0,
'increment_duration': increment_duration
}
- 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, 151) — shape (2, 151) 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
|
| filter |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/signal_processing.py code served (permissive licence) · get_code("9ccdc341527e4e3d") 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 iirfilter, lfilter, filtfilt
# Create a small synthetic signal
# The function expects a 1D numpy array and processes it with axis=0
# signal_properties dict needs an 'fs' key for sampling frequency
np.random.seed(0)
signal = np.random.randn(100) # Small 1D array of 100 samples
signal_properties = {
'fs': 250.0 # Sampling frequency in Hz
}
ARGS = {
'signal': signal,
'signal_properties': signal_properties
}
- 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
|
| filter_base |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/signal_processing.py code served (permissive licence) · get_code("02e50ac0d452d271") 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 (500,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
from scipy.signal import iirfilter, lfilter, filtfilt
np.random.seed(0)
# Create a simple 1D signal with some samples
signal = np.random.randn(500)
# Define ARGS with all parameters for filter_base
ARGS = {
'signal': signal,
'axis': -1,
'fs': 250.0
}
- 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 ndarray, ndim 1, dtype family float, shape (500,) — shape (500,) 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
|
| iir_bandpass_filter |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/signal_processing.py code served (permissive licence) · get_code("282ac4f0e343a8bf") 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 (1000,) 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 simple 1D signal for bandpass filtering
np.random.seed(0)
signal = np.random.randn(1000) # 1D array with 1000 samples
ARGS = {
'signal': signal,
'fs': 250.0,
'order': 4,
'frequency_band': [0.4, 18],
'filter_type': 'butter',
'axis': -1,
'forward_backward': False,
}
- 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 ndarray, ndim 1, dtype family float, shape (1000,) — shape (1000,) 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
|
| index_window |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/epoch_features_processing.py code served (permissive licence) · get_code("be0b88d3dbb9fec8") 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 (0, 1) 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 signal (audio-like data)
# Using 1000 samples at 100 Hz for 10 seconds
signal = np.random.randn(1000)
# Create signal_properties dict with sampling frequency
signal_properties = {
'fs': 100 # 100 Hz sampling frequency
}
# Define the ARGS dictionary with all parameters
ARGS = {
'signal': signal,
'signal_properties': signal_properties,
'increment_duration': 30,
'padding_duration': 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 ndarray, ndim 2, dtype family float, shape (0, 1) — shape (0, 1) 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
|
| kill_channel |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/datasets/data_augmentation.py code served (permissive licence) · get_code("b7851f924aab2ec7") 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 3, dtype family float, shape (2, 4, 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
# Set seed for reproducibility
np.random.seed(42)
# Create a small 3D numpy array with shape (batch=2, channels=4, spatial=3)
x = np.random.randn(2, 4, 3).astype(np.float32)
# Define probability parameter
p = 0.5
# Construct ARGS dict with all parameters
ARGS = {
'x': x,
'p': p
}
- 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 3, dtype family float, shape (2, 4, 3) — shape (2, 4, 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
|
| mask_non_scored_values |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/utils/scores.py code served (permissive licence) · get_code("efd2486d369320eb") 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 function. 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
def simple_metric(true, pred):
"""A simple metric function that compares true and pred values"""
return np.mean(true == pred)
def mask_non_scored_values(func):
""" We do not considere unlabeled data to estimate metrics"""
def lol(true, pred, *args, **kwargs):
true = np.array(true)
pred = np.array(pred)
mask = np.array([y in [0, 1, 2, 3, 4] for y in true])
return func(true[mask], pred[mask], *args, **kwargs)
return lol
ARGS = {
"func": simple_metric
}
- 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 function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
|
| memmap_hash |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/logger/logger.py code served (permissive licence) · get_code("548eb2a6d247f18e") 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 hashlib
import json
def memmap_hash(memmap_description):
return hashlib.sha1(json.dumps(memmap_description).encode()).hexdigest()[:10]
# The function takes memmap_description and converts it to JSON,
# then hashes it. memmap_description should be JSON-serializable.
# A typical memmap description would be a dict with metadata about memory-mapped arrays.
ARGS = {
"memmap_description": {
"filename": "data.bin",
"dtype": "float32",
"shape": [1000, 512],
"offset": 0,
"mode": "r"
}
}
- 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
|
| processs_group |
Ran ran on a synthesized input |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/h5_to_memmap.py code served (permissive licence) · get_code("87ffbd79b27cf280") 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 json
import numpy as np
from unittest.mock import MagicMock
# Create a mock h5 object with required attributes and methods
h5 = MagicMock()
# Create record description
record_description = [
{'path': 'signal1', 'fs': 100},
{'path': 'signal2', 'fs': 100},
]
h5.attrs = {'description': json.dumps(record_description)}
# Create mock datasets for signals
signal1_data = np.random.randn(1000).astype(np.float32)
signal2_data = np.random.randn(1000).astype(np.float32)
h5.__getitem__ = MagicMock(side_effect=lambda key: MagicMock(
__getitem__=lambda self, idx: signal1_data if key == 'signal1' else signal2_data
))
# Create group description
group_description = {
'signals': ['signal1', 'signal2'],
'processings': []
}
# Create signal_processings global dict (required by the function)
signal_processings = {}
ARGS = {
'h5': h5,
'group_description': group_description,
'truncate_to_second': 2
}
- 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
|
| compute_epoch_features |
Not yet run unverified (harvested, no recorded run) |
Dreem-Organization/dreem-learning-open/dreem_learning_open/preprocessings/h5_to_memmap.py code served (permissive licence) · get_code("1161728228a99af7") How it ran |
| inference_on_dataset |
Not yet run unverified (harvested, no recorded run) |
Dreem-Organization/dreem-learning-open/dreem_learning_open/logger/logger.py code served (permissive licence) · get_code("c7091685d495bb47") How it ran |
| torch_spectrogram |
Not yet run unverified (harvested, no recorded run) |
Dreem-Organization/dreem-learning-open/dreem_learning_open/models/modulo_net/normalization.py code served (permissive licence) · get_code("a31dce1f7ac6d818") How it ran |