| compute_fdr |
Ran ran on a synthesized input |
IBM/SIC/stattests.py code served (permissive licence) · get_code("d81b7960091f43e3") 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
# Set random seed for reproducibility
np.random.seed(0)
# Define arguments for compute_fdr
eta_sortix = np.array([0, 2, 5, 8, 1, 3]) # indices of top features sorted by some criterion
ground_truth = np.array([0, 2, 5]) # indices of true features
total_features = 20 # total number of features
axis = None # axis parameter for sum operations
cut_off = 40 # cutoff for number of features to consider
ARGS = {
"eta_sortix": eta_sortix,
"ground_truth": ground_truth,
"total_features": total_features,
"axis": axis,
"cut_off": cut_off,
}
- 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
|
| compute_mse |
Ran ran on a synthesized input |
IBM/SIC/SIC_imports.py code served (permissive licence) · get_code("6a9bfdd55c282718") 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 as nn
import torch.nn.functional as F
torch.manual_seed(0)
# Create a simple neural network that takes input and outputs predictions
class SimpleNet(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)
# Create network
net = SimpleNet(input_dim=4, output_dim=1)
# Create a simple dataloader as a list of (data, targets) tuples
# Batch size 2, input dimension 4, output dimension 1
dataloader = [
(torch.randn(2, 4), torch.randn(2, 1)),
(torch.randn(2, 4), torch.randn(2, 1)),
]
# Normalization parameters for targets
targets_mu = 0.0
targets_sd = 1.0
ARGS = {
'dataloader': dataloader,
'net': net,
'targets_mu': targets_mu,
'targets_sd': targets_sd,
}
- 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
|
| compute_objective_terms |
Ran ran on a synthesized input |
IBM/SIC/SIC_imports.py code served (permissive licence) · get_code("d07e6ab7af15ef76") 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 as nn
torch.manual_seed(0)
class SimpleNet(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, x, y):
# x shape: (batch, 4), y shape: (batch, 5)
# Return shape: (batch,)
return self.linear(x).sum(dim=1)
net = SimpleNet()
# Create data: (x, y) tuple
# x: batch_size=2, feature_dim=4
# y: batch_size=2, label_dim=5
x = torch.randn(2, 4)
y = torch.randn(2, 5)
data = (x, y)
ARGS = {
"data": data,
"net": net,
"need_penalty_terms": True
}
- 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
|
| describe |
Ran ran on a synthesized input |
IBM/SIC/utils.py code served (permissive licence) · get_code("d204ab0c6f9c28e9") 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 torch
import numpy as np
torch.manual_seed(0)
# Test with a numpy array
numpy_array = np.random.randn(2, 4).astype(np.float32)
# Test with a torch tensor
torch_tensor = torch.randn(3, 5)
# Create ARGS dict with both types to demonstrate the function works
ARGS = {
't': numpy_array
}
- 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 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
|
| dlist |
Ran ran on a synthesized input |
IBM/SIC/plot_results.py code served (permissive licence) · get_code("014bc653675795b0") 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 int, 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 numpy as np
# The function dlist takes:
# 1. key: a string to look up in dictionaries
# 2. dat: a list of dictionaries
# Create a list of dictionaries with varying content
dat = [
{'name': 'alice', 'age': 30, 'score': 95},
{'name': 'bob', 'score': 87}, # missing 'age'
{'name': 'charlie', 'age': 25, 'score': 92},
{'score': 88}, # missing 'name' and 'age'
]
ARGS = {
'key': 'score',
'dat': dat
}
- 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 int, 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
|
| get_data |
Ran ran on a synthesized input |
IBM/SIC/plot_results.py code served (permissive licence) · get_code("ea4d799e3e40806a") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import numpy as np
# Construct minimal valid arguments for get_data
# select_dict: list of dicts, each with one key-value pair used for filtering
select_dict = [
{'model_type': 'lstm'},
{'model_type': 'transformer'}
]
# key_list: list of keys to extract from filtered data
key_list = ['loss', 'accuracy']
# DAT: list of lists of dictionaries (data to filter and extract from)
DAT = [
[
{'loss': 0.5, 'accuracy': 0.8},
{'loss': 0.3, 'accuracy': 0.9}
],
[
{'loss': 0.4, 'accuracy': 0.85},
{'loss': 0.2, 'accuracy': 0.95}
],
[
{'loss': 0.6, 'accuracy': 0.75},
{'loss': 0.4, 'accuracy': 0.88}
]
]
# ARGS: list of dictionaries with filtering keys
ARGS = [
{'model_type': 'lstm', 'lr': 0.001},
{'model_type': 'transformer', 'lr': 0.0001},
{'model_type': 'cnn', 'lr': 0.01}
]
ARGS = {
'select_dict': select_dict,
'ARGS': ARGS,
'key_list': key_list,
'DAT': DAT
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| get_devices |
Ran ran on a synthesized input |
IBM/SIC/utils.py code served (permissive licence) · get_code("290087b87df2ac2e") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is 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)
ARGS = {
'cuda_device': 'cpu',
'seed': 1,
}
- 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, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| init_optimizerD |
Ran ran on a synthesized input |
IBM/SIC/modules/models.py code served (permissive licence) · get_code("74d8b31b37ed27e1") 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 Adam. 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)
# Create a simple discriminator model
class SimpleDiscriminator(nn.Module):
def __init__(self):
super().__init__()
self.features = nn.Sequential(
nn.Linear(4, 8),
nn.ReLU(),
nn.Linear(8, 16)
)
self.last_linear = nn.Linear(16, 1)
def forward(self, x):
x = self.features(x)
x = self.last_linear(x)
return x
# Create a simple config object with the required attributes
class OptConfig:
def __init__(self):
self.DiscArch = 'concat_first'
self.lrD = 0.0002
self.beta1 = 0.5
self.beta2 = 0.999
self.wdecay = 0.0
# Create instances
opt = OptConfig()
D = SimpleDiscriminator()
ARGS = {
'opt': opt,
'D': D,
'train_last_layer_only': False
}
- 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 Adam — a Adam output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Adam 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
|
| label_axis |
Ran ran on a synthesized input |
IBM/SIC/plot_results.py code served (permissive licence) · get_code("cedc42f38350b7b6") 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 Axes. 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 matplotlib.pyplot as plt
import numpy as np
# Create a minimal matplotlib axes object
fig, ax = plt.subplots()
# Plot some dummy data to initialize the axes properly
ax.plot([0, 1, 2], [0, 0.5, 1])
# Define labels for the x-axis
labels = ['Label A', 'Label B', 'Label C']
# Define x-axis positions (where labels should be placed)
xpos = [0.2, 0.5, 0.8]
# Define y-axis position for the spine offset
ypos = 10
# Define fontsize
fontsize = 14
# Define target FDR threshold
target_fdr = 0.05
ARGS = {
'ax': ax,
'labels': labels,
'xpos': xpos,
'ypos': ypos,
'fontsize': fontsize,
'target_fdr': target_fdr
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Axes — a Axes output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Axes 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
|
| linreg_reconstruct |
Ran ran on a synthesized input |
IBM/SIC/modules/linregression.py code served (permissive licence) · get_code("8e090872f4c05874") 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 LinRegression. 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)
# Create a small input tensor of size (batch_size=2, num_features=4)
X = torch.randn(2, 4)
# idx_feature is an integer index selecting which feature to reconstruct
idx_feature = 1
# eps is a float regularization parameter
eps = 1e-06
ARGS = {
"X": X,
"idx_feature": idx_feature,
"eps": eps
}
- 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 LinRegression — a LinRegression output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a LinRegression 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
|
| minibatch |
Ran ran on a synthesized input |
IBM/SIC/SIC_imports.py code served (permissive licence) · get_code("2f5a64db1f7ac832") 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
torch.manual_seed(0)
# Create small tensors for x and y
x = torch.randn(10, 4, requires_grad=False) # 10 samples, 4 features
y = torch.randn(10, 3, requires_grad=False) # 10 samples, 3 targets
# data is a tuple of (x, y)
data = (x, y)
# batch_size can be an integer or None/0
batch_size = 2
# requires_grad is a boolean
requires_grad = True
ARGS = {
"data": data,
"batch_size": batch_size,
"requires_grad": requires_grad,
}
- 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
|
| test_generator |
Ran ran on a synthesized input |
IBM/SIC/modules/generators.py code served (permissive licence) · get_code("a919d57070b61232") 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
import torch.nn as nn
torch.manual_seed(0)
# Create a minimal generator model that satisfies the function's requirements
class MinimalGenerator(nn.Module):
def __init__(self, feature_dim=4):
super().__init__()
self.feature_dim = feature_dim
self.linear = nn.Linear(feature_dim + 1, feature_dim)
def get_targets(self, data, labels):
# data shape: (batch_size, feature_dim)
# labels shape: (batch_size,)
# Return targets with same shape as outputs
return torch.randn(data.shape[0], self.feature_dim)
def sample_features(self, data_and_labels):
# data_and_labels is a tuple of (data, labels)
data, labels = data_and_labels
# data shape: (batch_size, feature_dim)
# labels shape: (batch_size,)
# Concatenate labels as float and pass through linear layer
labels_float = labels.float().unsqueeze(1)
combined = torch.cat([data, labels_float], dim=1)
return self.linear(combined)
# Create a minimal criterion (loss function)
criterion = nn.MSELoss()
# Create a minimal dataloader
# Each element should be a tuple where the first element is a tensor
# The function does data[0].to(device), so we need (tensor, dummy)
batch_size = 2
feature_dim = 4
dataloader = [
(torch.randn(batch_size, feature_dim), None),
(torch.randn(batch_size, feature_dim), None),
]
# Create the generator
generator = MinimalGenerator(feature_dim=feature_dim)
ARGS = {
"generator": generator,
"criterion": criterion,
"dataloader": dataloader,
"test_all_features": False,
}
- 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
|
| train_generator |
Ran ran on a synthesized input |
IBM/SIC/modules/generators.py code served (permissive licence) · get_code("adbde4eae22a3f8f") 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
import torch.nn as nn
import torch.optim as optim
torch.manual_seed(0)
# Define a minimal Generator class that satisfies the function's usage
class MinimalGenerator(nn.Module):
def __init__(self, num_features=4):
super().__init__()
self.num_features = num_features
self.linear = nn.Linear(num_features, num_features)
def training_loss(self, data, labels):
# Minimal loss computation using data and labels
output = self.linear(data)
loss = output.sum() + labels.float().sum()
return loss
# Create generator instance
generator = MinimalGenerator(num_features=4)
# Create a minimal dataloader (list of batches)
# Each batch is a tensor of shape (batch_size, num_features)
dataloader = [
torch.randn(2, 4),
torch.randn(2, 4),
]
# Wrap to have __len__ and __iter__
class SimpleDataLoader:
def __init__(self, data):
self.data = data
self.dataset = self
self.length = len(data)
def __len__(self):
return self.length
def __iter__(self):
return iter(self.data)
dataloader = SimpleDataLoader(dataloader)
# Create optimizer
optimizer = optim.SGD(generator.parameters(), lr=0.01)
# Features list (optional, will be set to range if None)
features_list = [0, 1, 2, 3]
# Log times
log_times = 2
ARGS = {
"generator": generator,
"dataloader": dataloader,
"optimizer": optimizer,
"features_list": features_list,
"log_times": log_times,
}
- 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
|
| init_D |
Not yet run unverified (harvested, no recorded run) |
IBM/SIC/modules/models.py code served (permissive licence) · get_code("fb54dc11aed4cbf8") How it ran |
| make_data_parallel |
Not yet run unverified (harvested, no recorded run) |
IBM/SIC/utils.py code served (permissive licence) · get_code("0b8190dcac4fd585") How it ran |
| risk_model_fn |
Not yet run unverified (harvested, no recorded run) |
IBM/SIC/run_baselines.py code served (permissive licence) · get_code("6c42a9c801164386") How it ran |
| train_sklearn_model |
Not yet run unverified (harvested, no recorded run) |
IBM/SIC/run_baselines.py code served (permissive licence) · get_code("8638295ef8c7c717") How it ran |