| calculate_freq_dist |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/blocks/negative_sampler.py code served (permissive licence) · get_code("1e93d604e778f7ba") 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 float, shape (8,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from collections import Counter
torch.manual_seed(0)
# The function expects:
# - data: an iterable where each element x can be passed to counter.update(x)
# Based on the code, x should be iterable (since counter.update(x) is called)
# This is typically a list of sequences/tokens
# - vocab_size: an integer representing the size of vocabulary
# Create sample data: a list of token sequences
# Each sequence is a list of token ids (integers from 0 to vocab_size-1)
vocab_size = 8
data = [
[0, 1, 2, 0, 1],
[3, 4, 5, 3],
[0, 2, 6, 7, 1, 0],
[4, 5, 2]
]
ARGS = {
'data': data,
'vocab_size': vocab_size
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch, tqdm — 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 float, shape (8,) — shape (8,) 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
|
| choose_negative_samples |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/blocks/negative_sampler.py code served (permissive licence) · get_code("2fbf0a00fadbc516") 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 2, dtype family int, shape (2, 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 numpy as np
class MockNegativeSampler:
"""Mock negative sampler that implements the sample method."""
def __init__(self, vocab_size=100):
self.vocab_size = vocab_size
def sample(self, k_neg):
"""Sample k_neg negative indices as numpy array."""
return np.random.randint(0, self.vocab_size, size=(2, k_neg))
torch.manual_seed(0)
np.random.seed(0)
ARGS = {
"negative_sampler": MockNegativeSampler(vocab_size=100),
"k_neg": 5
}
- 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 Tensor, ndim 2, dtype family int, shape (2, 5) — shape (2, 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
|
| configure_logger |
Ran ran; our contract draft was wrong, not the code |
rgalhama/diora/pytorch/diora/logging/configuration.py code served (permissive licence) · get_code("eafe1b97157e9ce2") 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 Logger. 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 logging
import tempfile
import os
# Create a temporary file for logging
temp_dir = tempfile.gettempdir()
log_file = os.path.join(temp_dir, 'test_diora.log')
ARGS = {
'log_file': log_file
}
- 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 Logger — a Logger output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Logger 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
|
| flatten_tree |
Ran ran, honoured the contract we drafted |
iesl/diora/pytorch/diora/scripts/parse.py code served (permissive licence) · get_code("be633fb138549fac") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 numpy as np
torch.manual_seed(0)
# The function flatten_tree recursively flattens nested structures (lists/tuples)
# into a single flat list. It checks if input is a list or tuple, and if so,
# recursively flattens each element. Otherwise it wraps the element in a list.
# Test with various nested structures
ARGS = {
"tr": [
1,
[2, 3],
(4, [5, 6]),
torch.tensor([7, 8, 9]),
[[10], 11],
(torch.randn(2, 4), np.array([12, 13]))
]
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- 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 — 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_inside_states |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/net/diora.py code served (permissive licence) · get_code("da754532b4ccd8b5") 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 3, 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)
class MockIndex:
def __init__(self):
self.inside_indices = {
(3, 0): (torch.tensor([0, 1]), torch.tensor([1, 2])),
(3, 1): (torch.tensor([0, 1]), torch.tensor([1, 2])),
}
def get_inside_index(self, length, level):
key = (length, level)
if key in self.inside_indices:
return self.inside_indices[key]
return torch.tensor([0, 1]), torch.tensor([1, 2])
class MockBatchInfo:
def __init__(self):
self.length = 3
self.level = 0
batch_info = MockBatchInfo()
chart = torch.randn(2, 5, 4)
index = MockIndex()
size = 4
ARGS = {
"batch_info": batch_info,
"chart": chart,
"index": index,
"size": size,
}
- 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 3, 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
|
| get_loss_funcs |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/net/trainer.py code served (permissive licence) · get_code("211c02eb344ded7f") 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)
# Build a minimal embedding layer
vocab_size = 10
embedding_dim = 4
embedding_layer = nn.Embedding(vocab_size, embedding_dim)
# Build a minimal options object
class Options:
def __init__(self):
self.hidden_dim = 5
self.k_neg = 3
self.margin = 1
self.cuda = False
self.reconstruct_mode = 'margin'
options = Options()
# batch_iterator is optional and not used in get_loss_funcs body
batch_iterator = None
ARGS = {
'options': options,
'batch_iterator': batch_iterator,
'embedding_layer': embedding_layer
}
- 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 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_offset_cache |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/net/offset_cache.py code served (permissive licence) · get_code("749881a9d1474de6") 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
# Construct arguments for get_offset_cache
# The function takes a single parameter 'length' which should be an integer
# It's used in arithmetic operations and as a range iterator
ARGS = {
"length": 5
}
- 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 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_ptb_format_from_diora_tree |
Ran ran; our contract draft was wrong, not the code |
iesl/diora/pytorch/diora/scripts/evalb.py code served (permissive licence) · get_code("dc405b16a06bb314") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 numpy as np
torch.manual_seed(0)
# Analyzing the function:
# - parse: a nested tree structure (tuples/lists) where leaves are indices
# - tokens: a list/array of token strings indexed by position
# - return_string: boolean flag
# - batched: boolean flag
#
# The function recursively processes parse trees, replacing indices with tokens,
# and optionally converting to string format.
# Create a simple parse tree structure (nested tuples/lists with integer indices as leaves)
# Example: (0, (1, 2)) represents a tree where 0 is left child, and (1,2) is right child
parse_tree = (0, (1, 2))
# Create a list of tokens that will be indexed by the parse tree
tokens_list = ["hello", "world", "test"]
ARGS = {
"parse": parse_tree,
"tokens": tokens_list,
"return_string": False,
"batched": False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — 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
|
| inside_compose |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/net/diora.py code served (permissive licence) · get_code("979fac5ee1a98b47") 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 2, dtype family float, shape (2, 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 torch
import torch.nn as nn
torch.manual_seed(0)
def compose_func(hs, cs):
"""Stand-in compose function that takes hidden states and cell states"""
return hs + cs
hs = torch.randn(2, 4)
cs = torch.randn(2, 4)
ARGS = {
"compose_func": compose_func,
"hs": hs,
"cs": cs,
}
- 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 2, dtype family float, shape (2, 4) — shape (2, 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
|
| inside_score |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/net/diora.py code served (permissive licence) · get_code("bd841f155656f991") 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 5, 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 simple score function that takes two tensors and returns a score tensor
class ScoreFunc(nn.Module):
def forward(self, h1, h2):
# h1 shape: (B, L, N) or similar
# h2 shape: (B, L, N) or similar
# Return shape should be broadcastable to (B, L, N)
return h1 + h2
score_func = ScoreFunc()
# Define batch_info with required attributes
class BatchInfo:
def __init__(self, batch_size, length, level):
self.batch_size = batch_size
self.length = length
self.level = level
batch_info = BatchInfo(batch_size=2, length=7, level=3)
# L = batch_info.length - batch_info.level = 7 - 3 = 4
# N = batch_info.level = 3
# B = batch_info.batch_size = 2
# hs is indexed as hs[0] and hs[1], both passed to score_func
# score_func returns something that can be added with ss[0] and ss[1]
# Result is viewed as (B, L, N, 1) = (2, 4, 3, 1)
# So s before view should be (2, 4, 3)
hs = [
torch.randn(2, 4, 3), # hs[0]
torch.randn(2, 4, 3), # hs[1]
]
# ss[0] and ss[1] are added to the score_func result
# They should be broadcastable to (2, 4, 3)
ss = [
torch.randn(2, 4, 3), # ss[0]
torch.randn(2, 4, 3), # ss[1]
]
ARGS = {
"score_func": score_func,
"batch_info": batch_info,
"hs": hs,
"ss": ss,
}
- 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 5, 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
|
| load_experiment |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/utils/checkpoint.py code served (permissive licence) · get_code("056af46d1aab23e9") 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 valid experiment data
temp_dir = tempfile.mkdtemp()
experiment_file = os.path.join(temp_dir, "experiment.json")
experiment_data = {
"model": "resnet50",
"learning_rate": 0.001,
"batch_size": 32,
"epochs": 10,
"metrics": ["accuracy", "loss"]
}
with open(experiment_file, 'w') as f:
json.dump(experiment_data, f)
ARGS = {
"experiment_file": experiment_file
}
- 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
|
| pick |
Ran ran on a synthesized input |
rgalhama/diora/pytorch/diora/misc/convert_conll_to_jsonl.py code served (permissive licence) · get_code("9d127c4fb21d72be") 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
torch.manual_seed(0)
# The function picks element k from each dictionary in a list
# It expects:
# - lst: a list of dictionaries
# - k: a key to extract from each dictionary
ARGS = {
"lst": [
{"a": 1, "b": 2, "c": 3},
{"a": 4, "b": 5, "c": 6},
{"a": 7, "b": 8, "c": 9},
],
"k": "b",
}
- 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 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
|
| postprocess |
Ran ran; our contract draft was wrong, not the code |
iesl/diora/pytorch/diora/scripts/parse.py code served (permissive licence) · get_code("97a72c5a047620b9") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) 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 numpy as np
# Define a simple tree structure with tokens
# The tree will be nested lists/tuples containing string tokens
# Example: [['word1', 'word2'], ['word3', '.']]
# Create a test tree where the last token is punctuation
tr = [['hello', 'world'], ['how', 'are', 'you', '.']]
# tokens parameter is optional, so we can pass None or a list
tokens = None
ARGS = {
'tr': tr,
'tokens': tokens
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — 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
|
| remove_using_flat_mask |
Ran ran, honoured the contract we drafted |
iesl/diora/pytorch/diora/scripts/parse.py code served (permissive licence) · get_code("88ba8def413739a5") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned tuple, ndim 2, dtype family int; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Analyzing the function:
# - tr: a tree structure that can be nested lists/tuples or leaf values
# - mask: a flat boolean array/list indexed by position during traversal
# The function traverses the tree in depth-first order and uses mask[pos]
# to decide whether to keep or remove each leaf node
# Create a simple tree structure with some leaf values
tree = [1, [2, 3], 4]
# Create a flat mask that corresponds to the leaves in order: 1, 2, 3, 4
# The traversal will visit leaves at positions 0, 1, 2, 3
# Let's keep some and remove others
mask = [True, False, True, False]
ARGS = {
"tr": tree,
"mask": mask,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 2, 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_ptb_format_from_nltk_tree |
Not yet run unverified (harvested, no recorded run) |
iesl/diora/pytorch/diora/scripts/evalb.py code served (permissive licence) · get_code("49e41cb57b27ffc0") How it ran |
| remove_punctuation_from_tree |
Not yet run unverified (harvested, no recorded run) |
iesl/diora/pytorch/diora/scripts/evalb.py code served (permissive licence) · get_code("2ef8eba0e3a234ce") How it ran |