| batch_pit_loss |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/pytorch_backend/loss.py code served (permissive licence) · get_code("89d4f325ff9c071b") 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 torch
import torch.nn.functional as F
import numpy as np
from itertools import permutations
torch.manual_seed(0)
# Create small sample tensors for batch_pit_loss
# ys: B-length list of predictions, each (T, C) shaped pre-activation values
# ts: B-length list of labels, each (T, C) shaped labels in {0, 1}
# Batch size = 2
# Time dimension T = 5 (distinct from C)
# Channel dimension C = 3 (distinct from T)
T = 5
C = 3
B = 2
# Create predictions (pre-activation logits)
ys = [
torch.randn(T, C), # First sample: (5, 3)
torch.randn(T, C), # Second sample: (5, 3)
]
# Create labels (binary values in {0, 1})
ts = [
torch.randint(0, 2, (T, C)).float(), # First sample: (5, 3)
torch.randint(0, 2, (T, C)).float(), # Second sample: (5, 3)
]
label_delay = 0
ARGS = {
"ys": ys,
"ts": ts,
"label_delay": label_delay,
}
- 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 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
|
| calc_diarization_error |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/pytorch_backend/loss.py code served (permissive licence) · get_code("977833339e01af8c") 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
torch.manual_seed(0)
# Create small tensors with distinct dimensions
# T=5 time steps, C=3 channels
T = 5
C = 3
# pred: (T, C) pre-activation values
pred = torch.randn(T, C)
# label: (T, C) binary labels in {0, 1}
label = torch.randint(0, 2, (T, C)).float()
# label_delay: offset parameter
label_delay = 1
ARGS = {
'pred': pred,
'label': label,
'label_delay': label_delay,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_input_dim |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/feature.py code served (permissive licence) · get_code("2f299371003065aa") 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 int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import numpy as np
torch.manual_seed(0)
# Analyze the function:
# - frame_size: int, used in bit_length() and arithmetic
# - context_size: int, used in arithmetic
# - transform_type: str, used with startswith()
# Construct valid arguments
frame_size = 8
context_size = 5
transform_type = 'logmel23'
ARGS = {
'frame_size': frame_size,
'context_size': context_size,
'transform_type': transform_type
}
- 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 int, ndim 0, dtype family int, 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
|
| load_sap |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/common_utils/dataset_correct.py code served (permissive licence) · get_code("13bd5877d13d5e3e") 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 h5py
import tempfile
import os
import numpy as np
# Create a temporary HDF5 file with the required 'T_hat' dataset
temp_dir = tempfile.mkdtemp()
temp_filepath = os.path.join(temp_dir, "test_data.h5")
# Create a sample HDF5 file
with h5py.File(temp_filepath, 'w') as f:
# Create a small sample tensor data
sample_data = np.random.rand(2, 4).astype(np.float32)
f.create_dataset('T_hat', data=sample_data)
ARGS = {
'filepath': temp_filepath
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- h5py, 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
|
| load_segments |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/kaldi_data.py code served (permissive licence) · get_code("216dff0f296d027f") 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 (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import os
import numpy as np
import tempfile
# Create a temporary segments file with valid data
temp_dir = tempfile.mkdtemp()
segments_file = os.path.join(temp_dir, "segments.txt")
# Write sample segment data in the format expected by loadtxt
with open(segments_file, 'w') as f:
f.write("utt_001 rec_001 0.5 1.5\n")
f.write("utt_002 rec_002 2.0 3.5\n")
ARGS = {
'segments_file': segments_file
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ndarray, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_segments_hash |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/kaldi_data.py code served (permissive licence) · get_code("805c93ef8140e802") 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 os
import tempfile
# Create a temporary segments file
temp_dir = tempfile.mkdtemp()
segments_file = os.path.join(temp_dir, "segments.txt")
# Write sample segment data
with open(segments_file, 'w') as f:
f.write("utt1 rec1 0.0 1.5\n")
f.write("utt2 rec1 1.5 3.2\n")
f.write("utt3 rec2 0.5 2.1\n")
ARGS = {
"segments_file": segments_file
}
- 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 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_segments_rechash |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/kaldi_data.py code served (permissive licence) · get_code("11ff0f39a6fdcd1e") 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 os
import tempfile
# Create a temporary segments file with test data
with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.txt') as f:
f.write("utt1 rec1 0.0 1.5\n")
f.write("utt2 rec1 1.5 3.0\n")
f.write("utt3 rec2 0.5 2.0\n")
segments_file_path = f.name
ARGS = {
"segments_file": segments_file_path
}
- 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 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_segments_rechash |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/common_utils/kaldi_data.py code served (permissive licence) · get_code("8972f961b497d9da") 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 os
import tempfile
# Create a temporary segments file for testing
temp_dir = tempfile.mkdtemp()
segments_file = os.path.join(temp_dir, "segments.txt")
# Write sample segment data to the file
with open(segments_file, 'w') as f:
f.write("utt1 rec1 0.0 1.5\n")
f.write("utt2 rec1 1.5 3.0\n")
f.write("utt3 rec2 0.5 2.0\n")
ARGS = {
"segments_file": segments_file
}
- 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 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_wav_scp |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/common_utils/dataset_correct.py code served (permissive licence) · get_code("fcdd1d00334209b8") 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 os
# Create a temporary wav.scp file with valid content
temp_dir = tempfile.mkdtemp()
wav_scp_path = os.path.join(temp_dir, "wav.scp")
# Write sample wav.scp content
# Format: recording_id /path/to/wav/file
with open(wav_scp_path, 'w') as f:
f.write("rec_001 /path/to/audio/file1.wav\n")
f.write("rec_002 /path/to/audio/file2.wav\n")
f.write("rec_003 /path/to/audio/file3.wav\n")
ARGS = {
"wav_scp_file": wav_scp_path
}
- 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 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_wav_scp |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/common_utils/kaldi_data.py code served (permissive licence) · get_code("4e95cba0484da8ff") 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 os
# Create a temporary wav.scp file for testing
temp_dir = tempfile.mkdtemp()
wav_scp_path = os.path.join(temp_dir, "wav.scp")
# Write sample content to the wav.scp file
# Format: rec_id wav_rxfilename
with open(wav_scp_path, 'w') as f:
f.write("rec001 /path/to/audio/file001.wav\n")
f.write("rec002 /path/to/audio/file002.wav\n")
f.write("rec003 /path/to/audio/file003.wav\n")
ARGS = {
"wav_scp_file": wav_scp_path
}
- 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 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
|
| my_collate |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/pytorch_backend/diarization_dataset.py code served (permissive licence) · get_code("36210d944a56c3e1") 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. 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
torch.manual_seed(0)
# The function my_collate expects a batch parameter
# which is an iterable of tuples, where each tuple contains (data, target)
# The function unpacks these using zip(*batch) and returns [data, target]
# Create a small batch with 2 samples
# Each sample is a tuple of (data, target)
batch = [
(torch.randn(4), torch.tensor(0)),
(torch.randn(4), torch.tensor(1))
]
ARGS = {
"batch": batch
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list — a list 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
|
| osd_loss |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/backend/losses.py code served (permissive licence) · get_code("c8758ad59f4753a7") 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 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn.functional as F
torch.manual_seed(0)
# ys: logits tensor, shape (batch, sequence, num_classes)
# ts: targets tensor, shape (batch, sequence, num_classes)
# The function uses these to compute OSD loss
batch_size = 2
sequence_length = 3
num_classes = 4
# ys should be logits (unbounded), used with sigmoid
ys = torch.randn(batch_size, sequence_length, num_classes)
# ts should be target labels, can contain -1 (ignored), 0, 1, etc.
# The function checks for values < 0 and uses them as ignore masks
ts = torch.tensor([
[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]],
[[0, 0, 0, 1], [-1, -1, -1, -1], [1, 1, 0, 0]]
], dtype=torch.float32)
ARGS = {
"ys": ys,
"ts": ts,
}
- 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 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
|
| pit_loss |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/pytorch_backend/loss.py code served (permissive licence) · get_code("6c112a64bf8d5421") 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 torch
import torch.nn.functional as F
torch.manual_seed(0)
# pred: (T, C)-shaped pre-activation values
# T=10 (time steps), C=4 (number of channels/sources)
pred = torch.randn(10, 4)
# label: (T, C)-shaped labels in {0, 1}
# Same shape as pred
label = torch.randint(0, 2, (10, 4)).float()
# label_delay: integer delay parameter
label_delay = 0
ARGS = {
"pred": pred,
"label": label,
"label_delay": label_delay,
}
- 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 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
|
| postprocess_output |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/infer.py code served (permissive licence) · get_code("380ee6404a7f71ea") 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 (20, 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
from scipy.signal import medfilt
# Create sample probability data
# Shape: (time_steps, num_speakers)
# Using 10 time steps and 3 speakers
probabilities = np.random.rand(10, 3)
# Subsampling factor
subsampling = 2
# Threshold for binarization
threshold = 0.5
# Median filter window length (must be odd)
median_window_length = 3
ARGS = {
"probabilities": probabilities,
"subsampling": subsampling,
"threshold": threshold,
"median_window_length": median_window_length,
}
- 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 2, dtype family float, shape (20, 3) — shape (20, 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
|
| setup_optimizer |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/backend/updater.py code served (permissive licence) · get_code("75294dcc89fb7683") 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 NoamOpt. 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 torch.optim as optim
from types import SimpleNamespace
torch.manual_seed(0)
# Create a simple model with parameters
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x):
return self.linear(x)
model = SimpleModel()
# Create args with different optimizer choices
args_adam = SimpleNamespace(
optimizer='adam',
lr=0.001,
hidden_size=512,
noam_warmup_steps=4000
)
args_sgd = SimpleNamespace(
optimizer='sgd',
lr=0.01,
hidden_size=512,
noam_warmup_steps=4000
)
args_noam = SimpleNamespace(
optimizer='noam',
lr=0.001,
hidden_size=512,
noam_warmup_steps=4000
)
ARGS = {
'args': args_noam,
'model': model
}
- 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 NoamOpt — a NoamOpt output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a NoamOpt 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
|
| sigmoid_inverse |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/infer_sap.py code served (permissive licence) · get_code("d9d88d2aeb7d7679") 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 1, dtype family float, shape (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)
# sigmoid_inverse takes a single parameter 'x' which should be a tensor
# The function applies log((x + EPS) / (1 - x + EPS))
# This expects x to be in a valid range for the sigmoid inverse (roughly 0 to 1)
# Create a small tensor with values in the valid range (0, 1)
x = torch.tensor([0.2, 0.5, 0.7, 0.9], dtype=torch.float32)
ARGS = {
"x": x
}
- 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 1, dtype family float, shape (4,) — shape (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
|
| splice |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/common_utils/features.py code served (permissive licence) · get_code("bdec7a99af6edff5") 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, 15) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Create a small feature array: (n_frames=5, n_featdim=3)
Y = np.random.randn(5, 3).astype(np.float32)
# Set context_size to a small value
context_size = 2
ARGS = {
"Y": Y,
"context_size": context_size,
}
- 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, 15) — shape (5, 15) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| subsample |
Ran ran on a synthesized input |
Yoshani/pytorch-sa-eend/eend/feature.py code served (permissive licence) · get_code("08f6950bcdfafc26") 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 torch
import numpy as np
torch.manual_seed(0)
# Y should be a tensor or array-like that supports slicing with [::]
# T should be a tensor or array-like that supports slicing with [::]
# subsampling is an integer that controls the step size
Y = torch.randn(8, 4) # 8 frames, 4 features
T = torch.randn(8, 3) # 8 frames, 3 different dimension
ARGS = {
"Y": Y,
"T": T,
"subsampling": 2
}
- 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 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
|
| vad_loss |
Ran ran on a synthesized input |
butspeechfit/diacorrect/diacorrect/backend/losses.py code served (permissive licence) · get_code("c54d0aa33d0eb502") 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 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# ys: logits tensor, shape (batch, time, features)
# ts: target tensor, shape (batch, time, features)
# The function performs operations like:
# - torch.sum on dimension 2
# - torch.sigmoid on ys
# - torch.prod on dimension 2
# - F.binary_cross_entropy
# - torch.max on dimension 2
# - torch.mean on dimension 2
batch_size = 2
time_steps = 4
features = 3
# Create ys: logits (can be any real values)
ys = torch.randn(batch_size, time_steps, features)
# Create ts: target tensor with values that are either -1 (padding) or non-negative
# Mix of -1 (padding) and valid values (0 or 1)
ts = torch.tensor([
[[1, 0, 1], [1, 1, 0], [-1, -1, -1], [0, 1, 1]],
[[1, 1, 1], [-1, 0, -1], [0, 0, 1], [1, 1, 0]]
], dtype=torch.float32)
ARGS = {
"ys": ys,
"ts": ts,
}
- 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 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
|
| get_rate |
Not yet run unverified (harvested, no recorded run) |
butspeechfit/diacorrect/diacorrect/backend/updater.py code served (permissive licence) · get_code("acb2c2991cd415dd") How it ran |
| pit_loss_multispk |
Not yet run unverified (harvested, no recorded run) |
butspeechfit/diacorrect/diacorrect/backend/losses.py code served (permissive licence) · get_code("61a0fbfaadc3465b") How it ran |