| calc_accuracy |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/utility_functions.py code served (permissive licence) · get_code("155d81bdb4a2fc74") 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 torch
torch.manual_seed(0)
# outputs: tensor that will have torch.max applied along dimension 1
# Expected shape: (batch_size, num_classes)
# We use batch_size=2, num_classes=4
outputs = torch.randn(2, 4)
# Y: target labels, compared against max_indices from outputs
# Expected shape: (batch_size,) with values in range [0, num_classes)
Y = torch.tensor([0, 2])
ARGS = {
"outputs": outputs,
"Y": Y,
}
- 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 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
|
| compute_acc |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/utility_functions.py code served (permissive licence) · get_code("38ec48431e45abd1") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Yhat: logits tensor with shape (batch_size, num_classes)
# The function calls torch.max(Yhat, 1) to get predicted class indices
Yhat = torch.randn(2, 4)
# Y: ground truth labels tensor with shape (batch_size,)
# The function compares predicted == Y, so Y should contain class indices (0 to num_classes-1)
Y = torch.tensor([0, 2])
ARGS = {
"Yhat": Yhat,
"Y": Y,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type float, ndim 0, dtype family float, shape () — shape () as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| covariance_diff_biased |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/fair_dummies_learning.py code served (permissive licence) · get_code("593e5ed0481b0f0a") 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)
# Create two small tensors with distinct dimensions
# Z: batch_size=2, features=4
Z = torch.randn(2, 4)
# W: batch_size=2, features=4
W = torch.randn(2, 4)
# scale parameter
scale = 1.0
ARGS = {
"Z": Z,
"W": W,
"scale": scale,
}
- 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
|
| density_estimation |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/utility_functions.py code served (permissive licence) · get_code("4df32aef40d16f61") 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 sample data for Y: 1D array of continuous values
Y = np.array([0.5, 1.2, 0.3, 1.8, 2.1, 0.7, 1.5, 0.9])
# Create sample data for A: binary treatment assignment (0 or 1)
A = np.array([0, 1, 0, 1, 0, 1, 1, 0])
# Create optional test data
Y_test = np.array([0.4, 1.3, 2.0, 0.6])
ARGS = {
'Y': Y,
'A': A,
'Y_test': Y_test
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| gen_synthetic_data |
Ran ran on a synthesized input |
yromano/fair_dummies/get_dataset.py code served (permissive licence) · get_code("61c33a916c6ce639") 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
ARGS = {
"n": 6000,
"seed": 0,
}
- 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
|
| get_coverage |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/cf_classification.py code served (permissive licence) · get_code("4fd60a8ea590875e") 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 numpy as np
torch.manual_seed(0)
# Y should be an integer index
Y = 1
# predicted_C should be indexable and contain boolean values
# The function does: predicted_C[int(Y)] == True
# So predicted_C needs to be a sequence/array with at least Y+1 elements
predicted_C = torch.tensor([False, True, False, True])
ARGS = {
"Y": Y,
"predicted_C": predicted_C
}
- 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
|
| get_length |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/cf_classification.py code served (permissive licence) · get_code("2ffe424106b5b1c8") 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 numpy as np
torch.manual_seed(0)
# Analyze the function:
# - get_length(Y, predicted_C) takes two parameters
# - It computes: length = sum(predicted_C)
# - Y is not used in the function body
# - predicted_C must be summable (list, tensor, or numpy array)
# Create small sample data
Y = torch.randn(2, 4) # Not used but required as parameter
# predicted_C should be summable - can be a list of integers or tensor
predicted_C = [2, 3] # Simple list of integers that sum to 5
ARGS = {
"Y": Y,
"predicted_C": predicted_C
}
- 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
|
| get_stat |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/cf_classification.py code served (permissive licence) · get_code("50b70e5728cd9316") 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 int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Analyzing the function:
# - Y: an integer index used to access predicted_C
# - predicted_C: a sequence/array that supports indexing and boolean comparison,
# and can be summed (needs to support sum() operation)
# Y should be a valid index into predicted_C
Y = 1
# predicted_C should be a boolean array/tensor where:
# - predicted_C[int(Y)] returns a boolean value
# - sum(predicted_C) works
# - We can check if it equals True
predicted_C = torch.tensor([False, True, False, True], dtype=torch.bool)
ARGS = {
"Y": Y,
"predicted_C": predicted_C
}
- 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, ndim 1, dtype family int — 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
|
| pretrain_adversary |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/fair_dummies_learning.py code served (permissive licence) · get_code("29bbbca9a634482a") 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 SimpleDiscriminator. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Define a simple model that takes x and outputs predictions
class SimpleModel(nn.Module):
def __init__(self, input_dim, output_dim):
super().__init__()
self.linear = nn.Linear(input_dim, output_dim)
def forward(self, x):
return self.linear(x)
# Define a simple discriminator
class SimpleDiscriminator(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.linear = nn.Linear(input_dim, 1)
def forward(self, x):
return self.linear(x)
def zero_grad(self):
super().zero_grad()
# Create model and discriminator
model = SimpleModel(input_dim=4, output_dim=3)
dis = SimpleDiscriminator(input_dim=3 + 5 + 6) # yhat(3) + a(5) + y(6)
# Create optimizer and criterion
optimizer = torch.optim.Adam(dis.parameters(), lr=0.001)
criterion = nn.BCEWithLogitsLoss(reduction='none')
# Create data loader: list of tuples (x, y, a, at)
# x: batch of inputs (2, 4)
# y: batch of labels (2, 6)
# a: batch of attributes (2, 5)
# at: batch of true attributes (2, 5)
data_loader = [
(torch.randn(2, 4), torch.randn(2, 6), torch.randn(2, 5), torch.randn(2, 5)),
(torch.randn(2, 4), torch.randn(2, 6), torch.randn(2, 5), torch.randn(2, 5)),
]
# lambdas should be a tensor for weighting the loss
lambdas = torch.ones(4, 1) # batch size 4 (2 real + 2 fake)
ARGS = {
'dis': dis,
'model': model,
'data_loader': data_loader,
'optimizer': optimizer,
'criterion': criterion,
'lambdas': lambdas,
}
- 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 SimpleDiscriminator — a SimpleDiscriminator output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleDiscriminator 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
|
| pretrain_adversary |
Ran ran on a synthesized input |
yromano/fair_dummies/others/adv_debiasing.py code served (permissive licence) · get_code("f80ebdfe287d35b2") 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 MinimalAdv. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Define a minimal classifier that outputs predictions
class MinimalClf(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 1)
def forward(self, x):
return self.linear(x)
# Define a minimal adversary that takes concatenated input
class MinimalAdv(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(3, 2) # p_y (1) + y (2) = 3 input dims, 2 output dims
def forward(self, x):
return self.linear(x)
# Create instances
adv = MinimalAdv()
clf = MinimalClf()
# Create a minimal data loader with (x, y, z) tuples
# x: batch_size=2, features=4
# y: batch_size=2, features=2
# z: batch_size=2, features=2
data_loader = [
(
torch.randn(2, 4),
torch.randn(2, 2),
torch.randn(2, 2)
),
(
torch.randn(2, 4),
torch.randn(2, 2),
torch.randn(2, 2)
)
]
# Create optimizer
optimizer = torch.optim.SGD(adv.parameters(), lr=0.01)
# Create loss criterion
criterion = nn.MSELoss(reduction='none')
# Create lambdas as a weight tensor matching the output size of adv
lambdas = torch.ones(2)
ARGS = {
'adv': adv,
'clf': clf,
'data_loader': data_loader,
'optimizer': optimizer,
'criterion': criterion,
'lambdas': lambdas
}
- 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 MinimalAdv — a MinimalAdv output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a MinimalAdv 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
|
| pretrain_adversary_fast_loader |
Ran ran on a synthesized input |
yromano/fair_dummies/fair_dummies/fair_dummies_learning.py code served (permissive licence) · get_code("dd0d940686cc5d71") 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 SimpleDiscriminator. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Build a simple discriminator model
class SimpleDiscriminator(nn.Module):
def __init__(self, input_dim):
super().__init__()
self.fc = nn.Linear(input_dim, 1)
def forward(self, x):
return self.fc(x)
# Build a simple model that produces predictions
class SimpleModel(nn.Module):
def __init__(self, output_dim):
super().__init__()
self.fc = nn.Linear(4, output_dim)
def forward(self, x):
return self.fc(x)
# Create instances
batch_size = 2
x_dim = 4
y_dim = 3
a_dim = 5
yhat_dim = 2
x = torch.randn(batch_size, x_dim)
y = torch.randn(batch_size, y_dim)
a = torch.randn(batch_size, a_dim)
at = torch.randn(batch_size, a_dim)
model = SimpleModel(yhat_dim)
dis = SimpleDiscriminator(yhat_dim + a_dim + y_dim)
optimizer = torch.optim.SGD(dis.parameters(), lr=0.01)
criterion = nn.BCEWithLogitsLoss(reduction='none')
lambdas = torch.ones(batch_size * 2, 1)
ARGS = {
'dis': dis,
'model': model,
'x': x,
'y': y,
'a': a,
'at': at,
'optimizer': optimizer,
'criterion': criterion,
'lambdas': lambdas
}
- 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 SimpleDiscriminator — a SimpleDiscriminator output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a SimpleDiscriminator 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
|
| read_crimes_data |
Ran ran on a synthesized input |
yromano/fair_dummies/get_dataset.py code served (permissive licence) · get_code("e31d738cefaa827e") 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 os
import tempfile
import shutil
# Create a temporary directory for test data
test_dir = tempfile.mkdtemp()
base_path = test_dir + '/'
# Create mock communities.names file
names_content = """@attribute state numeric
@attribute county numeric
@attribute community numeric
@attribute fold numeric
@attribute communityname string
@attribute racepctblack numeric
@attribute ViolentCrimesPerPop numeric
@attribute feature1 numeric
@attribute feature2 numeric
@attribute feature3 numeric
"""
with open(base_path + 'communities.names', 'w') as f:
f.write(names_content)
# Create mock communities.data file with sample data
import pandas as pd
import numpy as np
np.random.seed(42)
n_samples = 100
data_dict = {
'state': np.random.randint(0, 50, n_samples),
'county': np.random.randint(0, 200, n_samples),
'community': np.random.randint(0, 1000, n_samples),
'fold': np.random.randint(1, 11, n_samples),
'communityname': ['community'] * n_samples,
'racepctblack': np.random.uniform(0, 1, n_samples),
'ViolentCrimesPerPop': np.random.uniform(0, 1, n_samples),
'feature1': np.random.uniform(-10, 10, n_samples),
'feature2': np.random.uniform(-10, 10, n_samples),
'feature3': np.random.uniform(-10, 10, n_samples),
}
df = pd.DataFrame(data_dict)
df.to_csv(base_path + 'communities.data', header=False, index=False)
ARGS = {
'base_path': base_path
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas — 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
|
| read_meps_data |
Not yet run unverified (harvested, no recorded run) |
yromano/fair_dummies/get_dataset.py code served (permissive licence) · get_code("3db0f0aa6ae485cb") How it ran |
| train |
Not yet run unverified (harvested, no recorded run) |
yromano/fair_dummies/others/adv_debiasing.py code served (permissive licence) · get_code("f6d9e0317d4ec628") How it ran |
| train_regressor |
Not yet run unverified (harvested, no recorded run) |
yromano/fair_dummies/others/adv_debiasing.py code served (permissive licence) · get_code("46780301e5c26af6") How it ran |