| KLD |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/loss_functions.py code served (permissive licence) · get_code("35a868da9fed37c9") 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)
# Construct tiny tensors for mu and std
# mu and std are used in arithmetic operations and torch.sum, torch.log, torch.numel
# Keep them small: batch_size=2, dim=4
mu = torch.randn(2, 4)
std = torch.randn(2, 4).abs() + 0.1 # ensure positive values for log stability
ARGS = {
"mu": mu,
"std": std,
}
- 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
|
| augment_data |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/augmentation.py code served (permissive licence) · get_code("acecd7a6217e354d") 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 4, dtype family float, shape (2, 3, 4, 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 torch
import random
torch.manual_seed(0)
class Args:
def __init__(self):
self.hflip_p = 0.5
self.vflip_p = 0.3
self.random_translation = True
# Create a small batch of images
# Shape: (batch_size, channels, height, width) = (2, 3, 4, 5)
batch = torch.randn(2, 3, 4, 5)
args = Args()
ARGS = {
"batch": batch,
"args": args
}
- 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 4, dtype family float, shape (2, 3, 4, 5) — shape (2, 3, 4, 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
|
| augment_flip |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/augmentation.py code served (permissive licence) · get_code("4333c3e5ee86bb81") 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 4, dtype family float, shape (2, 3, 4, 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 torch
import random
torch.manual_seed(0)
# Create a small image tensor
# Shape: (batch=2, channels=3, height=4, width=5)
# The function uses torch.flip with dims [2] and [1], so we need at least 3 dimensions
img = torch.randn(2, 3, 4, 5)
# Probability parameters for horizontal and vertical flip
hflip_p = 0.5
vflip_p = 0.3
ARGS = {
"img": img,
"hflip_p": hflip_p,
"vflip_p": vflip_p,
}
- 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 4, dtype family float, shape (2, 3, 4, 5) — shape (2, 3, 4, 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
|
| augment_random_translate |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/augmentation.py code served (permissive licence) · get_code("77b460b279b0da2d") 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 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 torch
import random
torch.manual_seed(0)
random.seed(0)
# Create a small image tensor: (batch=2, height=4, width=3, channels=1)
# The function expects img.size(1) to be height, img.size(2) to be width
img = torch.randn(2, 4, 3)
ARGS = {
"img": img,
"random_factor": 0.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 Tensor, 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
|
| calc_distances_to_means |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/OpenSet/meta_recognition.py code served (permissive licence) · get_code("4bf4bed0805b9389") 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 torch
torch.manual_seed(0)
# Create small tensors for testing
# means: list of tensors representing class means
means = [
torch.randn(4), # mean for class 0
torch.randn(4), # mean for class 1
]
# tensors: list of tensors representing individual samples
tensors = [
torch.randn(4), # sample z for class 0
torch.randn(4), # sample z for class 1
]
# distance_function: string specifying which distance metric to use
distance_function = 'cosine'
ARGS = {
'means': means,
'tensors': tensors,
'distance_function': distance_function,
}
- 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 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
|
| encoder_loss_with_fake |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/loss_functions.py code served (permissive licence) · get_code("b3576c10e8d51fce") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Define a minimal args object with the margin attribute
class Args:
def __init__(self):
self.margin = 10.0
args = Args()
# Define device
device = torch.device('cpu')
# Create tiny tensors for the function inputs
batch_size = 2
num_classes = 4
feature_dim = 4
input_dim = 3
# Classification output and target
output_samples_classification = torch.randn(batch_size, num_classes)
target = torch.randint(0, num_classes, (batch_size,))
# Reconstruction output and input
output_samples_recon = torch.sigmoid(torch.randn(batch_size, input_dim))
inp = torch.randint(0, 2, (batch_size, input_dim)).float()
# Mean and std for real, reconstructed, and fake samples
real_mu = torch.randn(batch_size, feature_dim)
real_std = torch.abs(torch.randn(batch_size, feature_dim)) + 0.1
rec_mu = torch.randn(batch_size, feature_dim)
rec_std = torch.abs(torch.randn(batch_size, feature_dim)) + 0.1
fake_mu = torch.randn(batch_size, feature_dim)
fake_std = torch.abs(torch.randn(batch_size, feature_dim)) + 0.1
# Construct the ARGS dictionary
ARGS = {
'output_samples_classification': output_samples_classification,
'target': target,
'output_samples_recon': output_samples_recon,
'inp': inp,
'real_mu': real_mu,
'real_std': real_std,
'rec_mu': rec_mu,
'rec_std': rec_std,
'fake_mu': fake_mu,
'fake_std': fake_std,
'device': device,
'args': args,
}
- 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
|
| eval_dataset |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/evaluate.py code served (permissive licence) · get_code("5bb73bb78d01fb53") 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
import torch.nn as nn
import math
torch.manual_seed(0)
# Build a minimal model that satisfies the function's usage
class MinimalVAE(nn.Module):
def __init__(self, input_dim=4, latent_dim=3, num_classes=2):
super().__init__()
self.input_dim = input_dim
self.latent_dim = latent_dim
self.num_classes = num_classes
# Encoder
self.encoder_fc = nn.Linear(input_dim, latent_dim * 2)
# Classifier
self.classifier_fc = nn.Linear(latent_dim, num_classes)
# Decoder
self.decoder_fc = nn.Linear(latent_dim, input_dim)
# PixelCNN for autoregressive decoding
self.pixelcnn = nn.Linear(input_dim, input_dim)
def encode(self, x):
# x shape: (batch, input_dim)
x_flat = x.view(x.size(0), -1)
h = self.encoder_fc(x_flat)
mu = h[:, :self.latent_dim]
sigma = torch.exp(h[:, self.latent_dim:])
return mu, sigma
def reparameterize(self, mu, sigma):
eps = torch.randn_like(mu)
z = mu + sigma * eps
return z
def classifier(self, z):
return self.classifier_fc(z)
def decode(self, z):
return self.decoder_fc(z).view(z.size(0), 1, 2, 2)
def pixelcnn(self, inputs, priors):
return self.pixelcnn(inputs.view(inputs.size(0), -1)).view(inputs.size(0), 1, 2, 2)
class WrappedModel(nn.Module):
def __init__(self, vae):
super().__init__()
self.module = vae
def forward(self, x):
return self.module(x)
# Create model
vae = MinimalVAE(input_dim=4, latent_dim=3, num_classes=2)
model = WrappedModel(vae)
# Create minimal data loader
# Each batch should have shape (batch_size, input_dim) with some structure
data = [
(torch.randn(2, 1, 2, 2), torch.tensor([0, 1])),
(torch.randn(2, 1, 2, 2), torch.tensor([1, 0])),
]
ARGS = {
'model': model,
'data_loader': data,
'num_classes': 2,
'device': 'cpu',
'samples': 1,
'calc_reconstruction': False,
'autoregression': False,
}
- 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 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
|
| eval_openset_dataset |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/evaluate.py code served (permissive licence) · get_code("ff4c1bd619f2a04b") 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
import torch.nn as nn
import numpy as np
import math
torch.manual_seed(0)
# Define a minimal model that satisfies all the method calls in eval_openset_dataset
class MinimalVAEModel(nn.Module):
def __init__(self, num_classes=3, latent_dim=4, input_channels=1, input_size=8):
super().__init__()
self.num_classes = num_classes
self.latent_dim = latent_dim
self.input_channels = input_channels
self.input_size = input_size
# Encoder
self.encoder_fc = nn.Linear(input_channels * input_size * input_size, 16)
self.encoder_mu = nn.Linear(16, latent_dim)
self.encoder_sigma = nn.Linear(16, latent_dim)
# Classifier
self.classifier_fc = nn.Linear(latent_dim, num_classes)
# Decoder
self.decoder_fc1 = nn.Linear(latent_dim, 16)
self.decoder_fc2 = nn.Linear(16, input_channels * input_size * input_size)
# PixelCNN stub for autoregressive mode
self.pixelcnn = nn.Linear(1, 1)
def encode(self, x):
batch_size = x.size(0)
flat_x = x.view(batch_size, -1)
h = torch.relu(self.encoder_fc(flat_x))
mu = self.encoder_mu(h)
sigma = torch.exp(self.encoder_sigma(h))
return mu, sigma
def reparameterize(self, mu, sigma):
eps = torch.randn_like(mu)
z = mu + sigma * eps
return z
def classifier(self, z):
logits = self.classifier_fc(z)
return logits
def decode(self, z):
h = torch.relu(self.decoder_fc1(z))
recon = self.decoder_fc2(h)
recon = recon.view(z.size(0), self.input_channels, self.input_size, self.input_size)
return recon
class ModelWrapper(nn.Module):
def __init__(self, model):
super().__init__()
self.module = model
# Create data loader as list of (inputs, classes) tuples
def create_data_loader(batch_size=2, num_batches=1, input_channels=1, input_size=8, num_classes=3):
data_loader = []
for _ in range(num_batches):
inputs = torch.randn(batch_size, input_channels, input_size, input_size)
classes = torch.randint(0, num_classes, (batch_size,))
data_loader.append((inputs, classes))
return data_loader
# Setup arguments
base_model = MinimalVAEModel(num_classes=3, latent_dim=4, input_channels=1, input_size=8)
model = ModelWrapper(base_model)
data_loader = create_data_loader(batch_size=2, num_batches=1, input_channels=1, input_size=8, num_classes=3)
ARGS = {
'model': model,
'data_loader': data_loader,
'num_classes': 3,
'device': 'cpu',
'samples': 1,
'calc_reconstruction': False,
'autoregression': False,
}
- 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 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_feat_size |
Ran ran, honoured the contract we drafted |
MrtnMndt/OCDVAEContinualLearning/lib/Models/architectures.py code served (permissive licence) · get_code("8b8425aa050b8c28") 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 torch.nn as nn
torch.manual_seed(0)
# Create a simple block that processes input and outputs feature maps
class SimpleBlock(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1, stride=2)
def forward(self, x):
x = self.conv1(x)
x = self.conv2(x)
return x
block = SimpleBlock()
ARGS = {
"block": block,
"spatial_size": 4,
"ncolors": 3
}
- 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 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
|
| get_latent_embedding |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/Training/evaluate.py code served (permissive licence) · get_code("f28bb4760db0af78") 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 torch.nn as nn
torch.manual_seed(0)
# Build a minimal model with encode and reparameterize methods
class SimpleVAE(nn.Module):
def __init__(self, input_dim=4, latent_dim=3):
super().__init__()
self.encoder = nn.Linear(input_dim, latent_dim * 2)
self.input_dim = input_dim
self.latent_dim = latent_dim
def encode(self, x):
h = self.encoder(x)
mu = h[:, :self.latent_dim]
logstd = h[:, self.latent_dim:]
std = torch.exp(logstd)
return mu, std
def reparameterize(self, mu, std):
eps = torch.randn_like(std)
z = mu + eps * std
return z
# Wrap model to match the function's use of model.module
class ModelWrapper(nn.Module):
def __init__(self, vae):
super().__init__()
self.module = vae
# Create the VAE model
vae = SimpleVAE(input_dim=4, latent_dim=3)
model = ModelWrapper(vae)
# Create minimal data loader: list of (inputs, classes) tuples
# Batch size 2, input dim 4, 2 samples per class, 3 classes
data_loader = [
(torch.randn(2, 4), torch.tensor([0, 1])),
(torch.randn(2, 4), torch.tensor([2, 0])),
]
num_classes = 3
device = 'cpu'
ARGS = {
'model': model,
'data_loader': data_loader,
'num_classes': num_classes,
'device': device,
}
- 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 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
|
| get_means |
Ran ran on a synthesized input |
MrtnMndt/OCDVAEContinualLearning/lib/OpenSet/meta_recognition.py code served (permissive licence) · get_code("9a2c9f801548b8b5") 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 torch
torch.manual_seed(0)
# Create a list of tensors representing per-class z values
# Each tensor has shape (batch_size, feature_dim) with distinct dimensions
tensor_1 = torch.randn(2, 4) # 2 samples, 4 features
tensor_2 = torch.randn(3, 4) # 3 samples, 4 features
tensor_3 = torch.randn(2, 4) # 2 samples, 4 features
tensors_list = [tensor_1, tensor_2, tensor_3]
ARGS = {
"tensors_list": tensors_list
}
- 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 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
|
| surrogate_loss |
Ran ran on a synthesized input |
TimmHess/OCDVAEContinualLearning/lib/Models/si.py code served (permissive licence) · get_code("41cc1bfa6d07666f") 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
torch.manual_seed(0)
# Create a minimal model with named parameters
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(4, 3)
self.layer2 = nn.Linear(3, 2)
def forward(self, x):
return self.layer2(self.layer1(x))
model = SimpleModel()
# Create a storage_unit class that mimics the expected interface
class StorageUnit:
def __init__(self):
self._device_val = 'cpu'
# For each parameter in the model, create SI_prev_task and SI_omega attributes
# Replace '.' with '__' in parameter names as the function does
self.layer1__weight_SI_prev_task = torch.randn(3, 4)
self.layer1__weight_SI_omega = torch.abs(torch.randn(3, 4))
self.layer1__bias_SI_prev_task = torch.randn(3)
self.layer1__bias_SI_omega = torch.abs(torch.randn(3))
self.layer2__weight_SI_prev_task = torch.randn(2, 3)
self.layer2__weight_SI_omega = torch.abs(torch.randn(2, 3))
self.layer2__bias_SI_prev_task = torch.randn(2)
self.layer2__bias_SI_omega = torch.abs(torch.randn(2))
def _device(self):
return self._device_val
storage_unit = StorageUnit()
ARGS = {
'model': model,
'storage_unit': storage_unit
}
- 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
|
| joint_loss_function |
Not yet run unverified (harvested, no recorded run) |
MrtnMndt/OCDVAEContinualLearning/lib/Training/loss_functions.py code served (permissive licence) · get_code("13389065de3e98b6") How it ran |