| convert |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/generate-embed/pretrained/pretrained-generate-embed.py code served (permissive licence) · get_code("a34a68ec1f87d1c1") 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 islice
torch.manual_seed(0)
# The function takes two parameters:
# - lst: an iterable that will be converted to an iterator
# - var_lst: a list of integers specifying slice sizes
# Create a simple list to iterate over
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# Create a list of slice sizes
var_lst = [2, 3, 5]
ARGS = {
'lst': lst,
'var_lst': var_lst
}
- 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
|
| convert_timestamp |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/preprocess/create_full_dataset.py code served (permissive licence) · get_code("2e298fac74427689") 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 datetime
def convert_timestamp(timestamp):
"""
Convert timestamp from reddit to day, month and year
"""
date = datetime.datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S')
date_split = date.split('-')
month = int(date_split[1])
year = int(date_split[0])
return (month, year, date)
# Create a valid Unix timestamp (seconds since epoch)
# Using a timestamp from January 15, 2023
timestamp_value = 1673740800
ARGS = {
'timestamp': timestamp_value
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| generate_embeddings |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/generate-embed/pretrained/pretrained-generate-embed.py code served (permissive licence) · get_code("a3aad5d3c0c10547") 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 (1, 768) 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 tensorflow as tf
import numpy as np
class MockTokenizer:
def __init__(self):
self.cls_token_id = 101
def encode(self, sentence, add_special_tokens=True):
# Return a list of token ids
return [101, 2054, 2003, 1045, 102]
class MockRobertaModel(tf.Module):
def __init__(self):
super().__init__()
def __call__(self, input_ids):
# Simulate model output
batch_size = tf.shape(input_ids)[0]
seq_length = tf.shape(input_ids)[1]
# Return tuple with embeddings of shape [batch_size, seq_length, hidden_dim]
embeddings = tf.random.normal([batch_size, seq_length, 768])
return (embeddings,)
class MockDoc2VecModel:
def infer_vector(self, sentence):
# Return a 1D vector
return np.random.randn(768)
class MockXLNetModel(tf.Module):
def __init__(self):
super().__init__()
def __call__(self, input_ids):
batch_size = tf.shape(input_ids)[0]
seq_length = tf.shape(input_ids)[1]
embeddings = tf.random.normal([batch_size, seq_length, 768])
return (embeddings,)
class MockGPT2Tokenizer:
def __init__(self):
self.cls_token_id = 50256
def encode(self, sentence, add_special_tokens=True):
return [50256, 2054, 2003, 1045, 50256]
class MockGPT2Model(tf.Module):
def __init__(self):
super().__init__()
def __call__(self, input_ids):
batch_size = tf.shape(input_ids)[0]
seq_length = tf.shape(input_ids)[1]
embeddings = tf.random.normal([batch_size, seq_length, 768])
return (embeddings,)
# Create instances for testing with roberta-base
model_name = 'roberta-base'
model = MockRobertaModel()
sentence = "This is a test sentence"
tokenizer = MockTokenizer()
ARGS = {
'model_name': model_name,
'model': model,
'sentence': sentence,
'tokenizer': tokenizer,
'batch_size': 32
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, tensorflow — 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 (1, 768) — shape (1, 768) 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_dist |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/generate-embed/ft/seq_classification.py code served (permissive licence) · get_code("0d7d5e73ca198d40") 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 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)
# Analyze the function:
# - labels: iterable of integers (class indices)
# - nfclass: integer representing number of classes
# The function iterates over labels and indexes into per_class_count with each label
# Create small test data
labels = [0, 1, 0, 2, 1, 2, 2] # 7 samples across 3 classes
nfclass = 3
ARGS = {
"labels": labels,
"nfclass": nfclass
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family int — 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
|
| initialize_classifiers |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/sklearn_classifiers.py code served (permissive licence) · get_code("217dfb86b70c79c5") 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 numpy as np
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from xgboost import XGBClassifier
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
torch.manual_seed(0)
ARGS = {
'num_classes': 3,
'classifier_type': 'fast'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, sklearn, torch, xgboost — 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
|
| loadJsonFile |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/read_write_functions.py code served (permissive licence) · get_code("65d81b283d6d14fe") 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 json
import tempfile
import os
# Create a temporary JSON file with test data
test_data = {
"key1": "value1",
"key2": 42,
"key3": [1, 2, 3],
"nested": {
"inner_key": "inner_value"
}
}
# Write the test data to a temporary file
temp_dir = tempfile.gettempdir()
test_filepath = os.path.join(temp_dir, "test_data.json")
with open(test_filepath, 'w') as f:
json.dump(test_data, f)
ARGS = {
"filepath": test_filepath
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| loadPickleFile |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/read_write_functions.py code served (permissive licence) · get_code("d069cf3bd43db648") 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 pickle
import tempfile
import os
# Create a temporary pickle file with valid content
temp_dir = tempfile.mkdtemp()
temp_filepath = os.path.join(temp_dir, "test_file.pkl")
# Create a sample dictionary and pickle it
sample_dict = {
"key1": "value1",
"key2": [1, 2, 3],
"key3": {"nested": "dict"}
}
with open(temp_filepath, 'wb') as f:
pickle.dump(sample_dict, f)
ARGS = {
"filepath": temp_filepath
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| loadPickleFile |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/create-splits/create_splits.py code served (permissive licence) · get_code("f940e406bb65ae47") 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 pickle
import tempfile
import os
# Create a temporary pickle file with sample data
temp_dir = tempfile.gettempdir()
temp_filepath = os.path.join(temp_dir, "test_pickle_file.pkl")
sample_dict = {
"data": [1, 2, 3, 4, 5],
"metadata": {"name": "test", "version": 1},
"nested": {"key": "value"}
}
with open(temp_filepath, 'wb') as f:
pickle.dump(sample_dict, f)
# Define arguments for the function
ARGS = {
"filepath": temp_filepath,
"verbose": True,
"print_obj": False
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| load_dataset |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/generate-embed/ft/seq_classification.py code served (permissive licence) · get_code("ddffc0e8663801cd") 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 pandas as pd
import json
# Mock the loadJsonFile function since we can't do file I/O
def loadJsonFile(path):
"""Mock function that returns test data"""
pass
# Set the global min_nf_tokens
min_nf_tokens = 6
# Create test data structure
# The complete_dataset structure based on how it's used:
# complete_dataset[label1]['data'][commentID] should have:
# - 'classno': the label
# - 'comment': the text
# - 'nftokens': number of tokens (must be >= min_nf_tokens)
complete_dataset = {
'1': {
'data': {
'c1-comment1': {
'classno': 1,
'comment': 'This is a test comment with enough tokens.',
'nftokens': 8
},
'c1-comment2': {
'classno': 1,
'comment': 'Another test comment for validation.',
'nftokens': 7
}
}
},
'2': {
'data': {
'c2-comment1': {
'classno': 2,
'comment': 'A different class comment here.',
'nftokens': 6
}
}
},
'3': {
'data': {
'c3-comment1': {
'classno': 3,
'comment': 'Third class test comment with tokens.',
'nftokens': 7
},
'c3-comment2': {
'classno': 3,
'comment': 'More test data for testing purposes.',
'nftokens': 6
}
}
}
}
# Create ids structure with train/val/test splits
ids = {
'train': ['c1-comment1', 'c1-comment2'],
'val': ['c2-comment1'],
'test': ['c3-comment1', 'c3-comment2']
}
# Mock the loadJsonFile to return our test data
original_loadJsonFile = loadJsonFile
def loadJsonFile_mock(path):
if 'dataset' in path:
return complete_dataset
elif 'ids' in path:
return ids
return {}
# Patch it in the module where make_dataset and load_dataset are defined
import sys
current_module = sys.modules[__name__]
current_module.loadJsonFile = loadJsonFile_mock
ARGS = {
'dataset_path': 'test_dataset.json',
'ids_path': 'test_ids.json'
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- 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
|
| make_dataset |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/generate-embed/ft/seq_classification.py code served (permissive licence) · get_code("728e40674f6bf35c") 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
# Construct the complete_dataset structure
complete_dataset = {
'1': {
'data': {
'c1-comment1': {
'classno': 1,
'comment': 'This is a sample comment about the topic.',
'nftokens': 10
},
'c1-comment2': {
'classno': 1,
'comment': 'Another comment with sufficient tokens.',
'nftokens': 8
}
}
},
'2': {
'data': {
'c2-comment1': {
'classno': 2,
'comment': 'A different class comment here.',
'nftokens': 7
}
}
}
}
# Construct the ids list
ids = ['c1-comment1', 'c1-comment2', 'c2-comment1']
ARGS = {
'ids': ids,
'complete_dataset': complete_dataset
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- 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
|
| make_sets |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/create-splits/create_splits.py code served (permissive licence) · get_code("14a777d170409d8d") 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
torch.manual_seed(0)
# The function takes:
# - indexes: a list of indices
# - comment_ids: a list-like object that can be indexed
indexes = [0, 2, 1]
comment_ids = ["comment_001", "comment_002", "comment_003", "comment_004"]
ARGS = {
"indexes": indexes,
"comment_ids": comment_ids,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, 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
|
| openCSVfile |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/models/read_write_functions.py code served (permissive licence) · get_code("656cc72eb9b46d98") 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 csv
import tempfile
import os
# Create a temporary CSV file for testing
temp_dir = tempfile.mkdtemp()
temp_filepath = os.path.join(temp_dir, "test.csv")
# Write some sample CSV data
with open(temp_filepath, 'w', newline='') as f:
writer = csv.writer(f, delimiter=',')
writer.writerow(['col1', 'col2', 'col3'])
writer.writerow(['val1', 'val2', 'val3'])
writer.writerow(['val4', 'val5', 'val6'])
ARGS = {
'filepath': temp_filepath,
'delimiter': ','
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| openCSVfile |
Ran ran on a synthesized input |
LCS2-IIITD/ACL-FFLM/preprocess/create_full_dataset.py code served (permissive licence) · get_code("51db9a13268db992") 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 tempfile
import os
# Create a temporary CSV file with some sample data
temp_dir = tempfile.mkdtemp()
csv_filepath = os.path.join(temp_dir, "test.csv")
with open(csv_filepath, 'w') as f:
f.write("name,age,city\n")
f.write("Alice,30,New York\n")
f.write("Bob,25,Los Angeles\n")
f.write("Charlie,35,Chicago\n")
ARGS = {
'filepath': csv_filepath,
'delimiter': ','
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type 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
|
| make_paths |
Not yet run unverified (harvested, no recorded run) |
LCS2-IIITD/ACL-FFLM/models/classifiers/pretrained_classify_main_final.py code served (permissive licence) · get_code("0cc7fd039d01bf50") How it ran |
| new_classifier |
Not yet run unverified (harvested, no recorded run) |
LCS2-IIITD/ACL-FFLM/models/sklearn_classifiers.py code served (permissive licence) · get_code("246180ab9a03e813") How it ran |
| tokenize_words |
Not yet run unverified (harvested, no recorded run) |
LCS2-IIITD/ACL-FFLM/preprocess/create_full_dataset.py code served (permissive licence) · get_code("61dfa1c9e178c8b1") How it ran |