| activation_layer |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/main/activation.py code served (permissive licence) · get_code("e104b06ecdb1248e") 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 Dice. 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 tensorflow as tf
from tensorflow.python.keras.layers import Layer
import sys
# Test case 1: activation is a string 'dice'
activation_1 = 'dice'
# Test case 2: activation is a string 'relu'
activation_2 = 'relu'
# Test case 3: activation is a Layer subclass
class CustomActivation(Layer):
def call(self, inputs):
return tf.nn.relu(inputs)
activation_3 = CustomActivation
ARGS = {
'activation': 'dice'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Dice — a Dice output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Dice 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
|
| encoder_sparse_feature_train |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/data_process/feature_process.py code served (permissive licence) · get_code("b907dd863fd69ea0") 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 DataFrame. 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 pandas as pd
import tempfile
import os
# Create a temporary directory for data_cache
temp_dir = tempfile.mkdtemp()
os.makedirs(os.path.join(temp_dir, 'data_cache'), exist_ok=True)
# Patch the file paths in the function to use temp directory
import sys
from unittest.mock import patch
# Create sample dataframe with sparse features
df = pd.DataFrame({
'color': ['red', 'blue', 'red', 'green', 'blue'],
'size': ['S', 'M', 'L', 'S', 'M'],
'brand': ['A', 'B', 'A', 'C', 'B']
})
sparse_features = ['color', 'size', 'brand']
# Patch the file operations to use temp directory
original_open = open
def patched_open(file, *args, **kwargs):
if '../data_cache/' in file:
file = os.path.join(temp_dir, 'data_cache', os.path.basename(file))
elif '../data_cache_date.txt' in file:
file = os.path.join(temp_dir, 'data_cache_date.txt')
return original_open(file, *args, **kwargs)
# Apply patch
import builtins
builtins.open = patched_open
ARGS = {
'df': df,
'sparse_features': sparse_features
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 and dtype family int 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
|
| fit |
Ran ran on a synthesized input |
GitHub-HongweiZhang/prediction-flow/prediction_flow/pytorch/functions.py code served (permissive licence) · get_code("44610d575b31e33c") 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 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
import torch.nn as nn
torch.manual_seed(0)
# Define a simple model that accepts a batch dict and returns predictions
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, batch):
# batch is a dict with 'label' and other keys
x = batch.get('features', batch['label'])
return self.linear(x)
# Define a loss function
loss_fn = nn.CrossEntropyLoss()
# Create model and optimizer
model = SimpleModel()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
# Create train loader - list of batches with 'features' and 'label' keys
train_loader = [
{
'features': torch.randn(2, 4),
'label': torch.randint(0, 3, (2,))
},
{
'features': torch.randn(2, 4),
'label': torch.randint(0, 3, (2,))
}
]
# Create valid loader
valid_loader = [
{
'features': torch.randn(2, 4),
'label': torch.randint(0, 3, (2,))
}
]
ARGS = {
'epochs': 2,
'model': model,
'loss': loss_fn,
'optimizer': optimizer,
'train_loader': train_loader,
'valid_loader': valid_loader,
'notebook': False,
'auxiliary_loss_rate': 0.0
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, 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_fixlen_feature_names |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/main/inputs.py code served (permissive licence) · get_code("d6b137f539161a96") 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 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.
from collections import OrderedDict, namedtuple
from tensorflow.python.keras.layers import Embedding, Input, Flatten
class SparseFeat(namedtuple('SparseFeat', ['name', 'dimension', 'use_hash', 'dtype', 'embedding_name', 'embedding'])):
__slots__ = ()
def __new__(cls, name, dimension, use_hash=False, dtype='int32', embedding_name=None, embedding=True):
if embedding and embedding_name is None:
embedding_name = name
return super(SparseFeat, cls).__new__(cls, name, dimension, use_hash, dtype, embedding_name, embedding)
class DenseFeat(namedtuple('DenseFeat', ['name', 'dimension', 'dtype'])):
__slots__ = ()
def __new__(cls, name, dimension=1, dtype='float32'):
return super(DenseFeat, cls).__new__(cls, name, dimension, dtype)
class VarLenSparseFeat(namedtuple('VarLenFeat', ['name', 'dimension', 'maxlen', 'combiner', 'use_hash', 'dtype', 'embedding_name', 'embedding'])):
__slots__ = ()
def __new__(cls, name, dimension, maxlen, combiner='mean', use_hash=False, dtype='float32', embedding_name=None, embedding=True):
if embedding_name is None:
embedding_name = name
return super(VarLenSparseFeat, cls).__new__(cls, name, dimension, maxlen, combiner, use_hash, dtype, embedding_name, embedding)
def build_input_features(feature_columns, include_varlen=True, mask_zero=True, prefix='', include_fixlen=True):
input_features = OrderedDict()
if include_fixlen:
for fc in feature_columns:
if isinstance(fc, SparseFeat):
input_features[fc.name] = Input(shape=(1,), name=prefix + fc.name, dtype=fc.dtype)
elif isinstance(fc, DenseFeat):
input_features[fc.name] = Input(shape=(fc.dimension,), name=prefix + fc.name, dtype=fc.dtype)
if include_varlen:
for fc in feature_columns:
if isinstance(fc, VarLenSparseFeat):
input_features[fc.name] = Input(shape=(fc.maxlen,), name=prefix + 'seq_' + fc.name, dtype=fc.dtype)
if not mask_zero:
for fc in feature_columns:
input_features[fc.name + '_seq_length'] = Input(shape=(1,), name=prefix + 'seq_length_' + fc.name)
input_features[fc.name + '_seq_max_length'] = fc.maxlen
return input_features
def get_fixlen_feature_names(feature_columns):
features = build_input_features(feature_columns, include_varlen=False, include_fixlen=True)
return list(features.keys())
feature_columns = [
SparseFeat('user_id', dimension=100),
SparseFeat('item_id', dimension=200),
DenseFeat('price', dimension=1),
DenseFeat('rating', dimension=2),
]
ARGS = {
'feature_columns': feature_columns,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- tensorflow — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, 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_input |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/data_process/feature_process_parallel.py code served (permissive licence) · get_code("92cd6e35ce4dd619") 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 DataFrame. 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 pandas as pd
torch.manual_seed(0)
# Create a simple DataFrame
df = pd.DataFrame({
'col1': [1, 2, 3, 4],
'col2': [5.0, 6.0, 7.0, 8.0],
'col3': ['a', 'b', 'c', 'd']
})
ARGS = {
'df': df
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- pandas, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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_inputs_list |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/main/inputs.py code served (permissive licence) · get_code("05796c38e27e1f97") 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
from itertools import chain
torch.manual_seed(0)
def get_inputs_list(inputs):
return list(chain(*list(map(lambda x: x.values(), filter(lambda x: x is not None, inputs)))))
# The function expects 'inputs' to be an iterable of dict-like objects (or None)
# It filters out None values, then maps over remaining dicts to get their values(),
# then chains all those value iterables together into a single list
# Create test data: a list containing some dicts and None values
inputs_data = [
{"key1": torch.randn(2, 4), "key2": torch.randn(3, 5)},
None,
{"key3": torch.randn(2, 3)},
{"key4": torch.randn(1, 2), "key5": torch.randn(4, 1)}
]
ARGS = {
"inputs": inputs_data
}
- 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_stats |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/data_process/utils.py code served (permissive licence) · get_code("ccf9fd2e5c97ebea") 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 DataFrame. 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 pandas as pd
import numpy as np
# Create a small DataFrame with various data types and some missing values
df = pd.DataFrame({
'int_col': [1, 2, 3, 4, 5],
'float_col': [1.5, 2.5, np.nan, 4.5, 5.5],
'str_col': ['a', 'b', 'a', 'c', 'd'],
'bool_col': [True, False, True, np.nan, False]
})
ARGS = {
'df': df
}
- 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 DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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_varlen_feature_names |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/main/inputs.py code served (permissive licence) · get_code("3265836b7310a8ee") 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 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 numpy as np
from collections import OrderedDict, namedtuple
from tensorflow.python.keras.layers import Embedding, Input, Flatten
class SparseFeat(namedtuple('SparseFeat', ['name', 'dimension', 'use_hash', 'dtype', 'embedding_name', 'embedding'])):
__slots__ = ()
def __new__(cls, name, dimension, use_hash=False, dtype='int32', embedding_name=None, embedding=True):
if embedding and embedding_name is None:
embedding_name = name
return super(SparseFeat, cls).__new__(cls, name, dimension, use_hash, dtype, embedding_name, embedding)
class DenseFeat(namedtuple('DenseFeat', ['name', 'dimension', 'dtype'])):
__slots__ = ()
def __new__(cls, name, dimension=1, dtype='float32'):
return super(DenseFeat, cls).__new__(cls, name, dimension, dtype)
class VarLenSparseFeat(namedtuple('VarLenFeat', ['name', 'dimension', 'maxlen', 'combiner', 'use_hash', 'dtype', 'embedding_name', 'embedding'])):
__slots__ = ()
def __new__(cls, name, dimension, maxlen, combiner='mean', use_hash=False, dtype='float32', embedding_name=None, embedding=True):
if embedding_name is None:
embedding_name = name
return super(VarLenSparseFeat, cls).__new__(cls, name, dimension, maxlen, combiner, use_hash, dtype, embedding_name, embedding)
feature_columns = [
SparseFeat('sparse_1', dimension=10),
DenseFeat('dense_1', dimension=3),
VarLenSparseFeat('varlen_1', dimension=5, maxlen=4),
VarLenSparseFeat('varlen_2', dimension=8, maxlen=6),
]
ARGS = {
'feature_columns': feature_columns,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, 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
|
| predict |
Ran ran on a synthesized input |
GitHub-HongweiZhang/prediction-flow/prediction_flow/pytorch/functions.py code served (permissive licence) · get_code("c3d04f508c82a301") 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 (4, 3) as a later run recorded it. 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, 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)
class SimpleModel(nn.Module):
def __init__(self):
super().__init__()
self.linear = nn.Linear(4, 3)
def forward(self, batch):
x = batch['input']
return self.linear(x)
model = SimpleModel()
test_loader = [
{'input': torch.randn(2, 4)},
{'input': torch.randn(2, 4)},
]
ARGS = {
'model': model,
'test_loader': test_loader,
}
- 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 ndarray, ndim 2, dtype family float, shape (4, 3) — shape (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
|
| reduce_mem_usage_sd |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/data_process/utils.py code served (permissive licence) · get_code("7c6c9f847c54ad28") 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 DataFrame. 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 pandas as pd
import numpy as np
# Create a small test DataFrame with various numeric types
np.random.seed(0)
df = pd.DataFrame({
'int_col': np.array([1, 2, 3, 4, 5], dtype='int64'),
'float_col': np.array([1.1, 2.2, 3.3, 4.4, 5.5], dtype='float64'),
'uint_col': np.array([10, 20, 30, 40, 50], dtype='uint64'),
'mixed_col': np.array([1.0, 2.0, np.nan, 4.0, 5.0], dtype='float64'),
})
ARGS = {
'df': df,
'deep': True,
'verbose': False,
'obj_to_cat': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
|
| sd |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/data_process/utils.py code served (permissive licence) · get_code("48dfdb09af366938") 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 Series. 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
import pandas as pd
# Create a small pandas Series with float values for testing
np.random.seed(0)
col = pd.Series([1.5, 2.7, 3.2, 4.1, 5.9, np.nan, 7.3, 8.8])
ARGS = {
'col': col,
'max_loss_limit': 0.001,
'avg_loss_limit': 0.001,
'na_loss_limit': 0,
'n_uniq_loss_limit': 0,
'fillna': 0
}
- 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 Series — a Series output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Series output the recorded ndim 1 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
|
| truncated_sequence |
Ran ran on a synthesized input |
kupuSs/DIEN-pipline/data_process/feature_process.py code served (permissive licence) · get_code("c1acb34b5eb2c10f") 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 DataFrame. 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 pandas as pd
import numpy as np
# Create a small dataframe with sequence_features
# The function expects columns with pipe-separated string values
df = pd.DataFrame({
'seq_col_1': [
'token1|token2|token3|token4|token5|token6|token7|token8|token9|token10|token11|token12|token13|token14|token15|token16|token17|token18|token19|token20|token21|token22|token23|token24|token25',
'a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z'
],
'seq_col_2': [
'x1|x2|x3|x4|x5|x6|x7|x8|x9|x10|x11|x12|x13|x14|x15|x16|x17|x18|x19|x20|x21|x22',
'y1|y2|y3|y4|y5|y6|y7|y8|y9|y10|y11|y12|y13|y14|y15'
]
})
sequence_features = ['seq_col_1', 'seq_col_2']
limit = 20
ARGS = {
'df': df,
'sequence_features': sequence_features,
'limit': limit
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, pandas, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 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
|
| auxiliary_net |
Not yet run unverified (harvested, no recorded run) |
kupuSs/DIEN-pipline/main/dien.py code served (permissive licence) · get_code("8f14a15b98aa8424") How it ran |
| encoder_sparse_feature_test |
Not yet run unverified (harvested, no recorded run) |
kupuSs/DIEN-pipline/data_process/feature_process.py code served (permissive licence) · get_code("78b96bd66f1811b1") How it ran |