| bbox_to_ecp_format |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/inference_standard_yolov3.py code served (permissive licence) · get_code("24e74d320a0d45b8") 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 numpy as np
import torch
import torch.nn as nn
# Create a minimal model that has the attributes accessed in the function
class MinimalModel(nn.Module):
def __init__(self):
super().__init__()
self.cls_start_idx = 5
self.cls_cnt = 2
self.obj_idx = 4
model = MinimalModel()
# Create bbox as a numpy array with values in appropriate ranges
# bbox needs at least: indices 0-3 (coordinates), obj_idx (4), cls_start_idx to cls_start_idx+cls_cnt (5-6)
bbox = np.array([
0.1, # bbox[0] - normalized y0
0.2, # bbox[1] - normalized x0
0.8, # bbox[2] - normalized y1
0.9, # bbox[3] - normalized x1
0.95, # bbox[4] - objectness score at obj_idx
0.3, # bbox[5] - class 0 score at cls_start_idx
0.7, # bbox[6] - class 1 score at cls_start_idx + 1
], dtype=np.float32)
# Image size [height, width]
img_size = np.array([480, 640])
# Configuration dictionary with the implicit_background_class key
config = {
'implicit_background_class': True
}
ARGS = {
'bbox': bbox,
'img_size': img_size,
'model': model,
'config': config
}
- 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
|
| bbox_to_ecp_format |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/inference_aleatoric.py code served (permissive licence) · get_code("bdd1738736106015") 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 numpy as np
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a minimal model with the required attributes
class MinimalModel(nn.Module):
def __init__(self):
super().__init__()
self.cls_start_idx = 9
self.cls_cnt = 2
self.obj_idx = 4
def forward(self, x):
return x
# Create the bbox array with required indices
# bbox needs at least: [0]=y0_norm, [1]=x0_norm, [2]=y1_norm, [3]=x1_norm,
# [4]=x_var, [5]=y_var, [6]=w_var, [7]=h_var, [8]=total_var,
# [obj_idx]=obj_score, [obj_idx+1]=obj_entropy,
# [cls_start_idx:cls_start_idx+cls_cnt]=cls_scores,
# [cls_start_idx+cls_cnt]=cls_entropy
model = MinimalModel()
# Build bbox array with all required elements
bbox = np.zeros(12, dtype=np.float32)
bbox[0] = 0.1 # y0 normalized
bbox[1] = 0.2 # x0 normalized
bbox[2] = 0.5 # y1 normalized
bbox[3] = 0.7 # x1 normalized
bbox[4] = 0.01 # x_var
bbox[5] = 0.02 # y_var
bbox[6] = 0.03 # w_var
bbox[7] = 0.04 # h_var
bbox[8] = 0.1 # total_var
bbox[model.obj_idx] = 0.8 # obj_score (index 4)
bbox[model.obj_idx + 1] = 0.15 # obj_entropy (index 5)
bbox[model.cls_start_idx:model.cls_start_idx + model.cls_cnt] = [0.9, 0.1] # cls_scores (indices 9-10)
bbox[model.cls_start_idx + model.cls_cnt] = 0.5 # cls_entropy (index 11)
img_size = (480, 640, 3)
config = {
'implicit_background_class': True
}
ARGS = {
'bbox': bbox,
'img_size': img_size,
'model': model,
'config': config
}
- 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
|
| bbox_to_ecp_format |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/inference_epistemic.py code served (permissive licence) · get_code("8a5715edef2f0423") 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 numpy as np
import torch
import torch.nn as nn
torch.manual_seed(0)
# Create a minimal model class that provides the attributes used in the function
class MinimalModel(nn.Module):
def __init__(self):
super().__init__()
self.cls_start_idx = 14
self.cls_cnt = 2
self.obj_idx = 3
def forward(self, x):
return x
# Create a minimal config dict
config = {
'implicit_background_class': True
}
# Create a bbox with all required indices
# Indices 0-3: y0, x0, y1, x1 (normalized coordinates)
# Indices 4-7: x_var_epi, y_var_epi, w_var_epi, h_var_epi
# Indices 8-11: x_var_ale, y_var_ale, w_var_ale, h_var_ale
# Indices 12-13: total_var_epi, total_var_ale
# Index 3 (obj_idx): objectness score
# Indices 4-5 (obj_idx+1, obj_idx+2): obj_mutual_info, obj_entropy
# Indices 14-15 (cls_start_idx): cls_scores for 2 classes
# Indices 16-17: ped_score, rider_score (at indices 17-18 in output, but accessed as bbox[17], bbox[18])
# Indices 16-19 (cls_start_idx + cls_cnt to cls_start_idx + cls_cnt + 3): cls_mutual_info, cls_entropy, layer_id, prior_id
bbox = np.array([
0.1, # 0: y0 (normalized)
0.2, # 1: x0 (normalized)
0.5, # 2: y1 (normalized)
0.7, # 3: x1 (normalized) -- also obj_idx
0.01, # 4: x_var_epi
0.02, # 5: y_var_epi
0.03, # 6: w_var_epi
0.04, # 7: h_var_epi
0.05, # 8: x_var_ale
0.06, # 9: y_var_ale
0.07, # 10: w_var_ale
0.08, # 11: h_var_ale
0.15, # 12: total_var_epi
0.25, # 13: total_var_ale
0.8, # 14: cls_scores[0] (pedestrian)
0.2, # 15: cls_scores[1] (rider)
0.9, # 16: ped_score
0.85, # 17: rider_score (accessed as bbox[18], so we need one more entry)
0.12, # 18: cls_mutual_info (cls_start_idx + cls_cnt = 14 + 2 = 16... wait)
], dtype=np.float32)
# Recalculate: cls_start_idx=14, cls_cnt=2
# cls_scores are at indices 14-15
# obj_idx = 3
# obj_mutual_info at obj_idx+1 = 4
# obj_entropy at obj_idx+2 = 5
# ped_score at bbox[17]
# rider_score at bbox[18]
# cls_mutual_info at cls_start_idx + cls_cnt = 16
# cls_entropy at cls_start_idx + cls_cnt + 1 = 17
# layer_id at cls_start_idx + cls_cnt + 2 = 18
# prior_id at cls_start_idx + cls_cnt + 3 = 19
# Rebuild bbox with correct structure
bbox = np.array([
0.1, # 0: y0
0.2, # 1: x0
0.5, # 2: y1
0.7, # 3: x1 / obj_idx
0.01, # 4: x_var_epi / obj_mutual_info
0.02, # 5: y_var_epi / obj_entropy
0.03, # 6: w_var_epi
0.04, # 7: h_var_epi
0.05, # 8: x_var_ale
0.06, # 9: y_var_ale
0.07, # 10: w_var_ale
0.08, # 11: h_var_ale
0.15, # 12: total_var_epi
0.25, # 13: total_var_ale
0.8, # 14: cls_scores[0]
0.2, # 15: cls_scores[1]
0.12, # 16: cls_mutual_info
0.85, # 17: ped_score / cls_entropy
0.9, # 18: rider_score / layer_id
0.05, # 19: prior_id
], dtype=np.float32)
img_size = (480, 640, 3)
model = MinimalModel()
ARGS = {
'bbox': bbox,
'img_size': img_size,
'model': model,
'config': config
}
- 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
|
| bytes_feature |
Ran ran; our contract draft was wrong, not the code |
flkraus/bayesian-yolov3/create_tf_records_citypersons.py code served (permissive licence) · get_code("d682a9593710857e") 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 Feature. 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
# bytes_feature expects a single parameter 'value' which should be bytes
# The function wraps it in tf.train.BytesList and then tf.train.Feature
ARGS = {
"value": b"example_bytes_data"
}
- 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 Feature — a Feature output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Feature 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
|
| concat_bbox |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/inference_standard_yolov3.py code served (permissive licence) · get_code("6ba1ae5ae4da3d61") 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 EagerTensor, ndim 3, dtype family float, shape (2, 36, 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 tensorflow as tf
import numpy as np
# Create a mock net_out structure that the function iterates over
# The function expects: net_out -> det_layer -> prior with shape [batches, lw, lh, det_size]
# Create sample prior tensors with distinct dimensions
# batches=2, lw=3, lh=4, det_size=5
prior1 = tf.constant(np.random.randn(2, 3, 4, 5), dtype=tf.float32)
prior2 = tf.constant(np.random.randn(2, 3, 4, 5), dtype=tf.float32)
# Create det_layer as list of priors
det_layer1 = [prior1, prior2]
det_layer2 = [prior1]
# Create net_out as list of detection layers
net_out = [det_layer1, det_layer2]
ARGS = {
"net_out": net_out
}
- 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 EagerTensor, ndim 3, dtype family float, shape (2, 36, 5) — shape (2, 36, 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
|
| int64_feature |
Ran ran; our contract draft was wrong, not the code |
flkraus/bayesian-yolov3/create_tf_records_citypersons.py code served (permissive licence) · get_code("328d17201d9a0e68") 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 Feature. 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
def int64_feature(value):
return tf.train.Feature(int64_list=tf.train.Int64List(value=[value]))
ARGS = {
"value": 42
}
- 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 Feature — a Feature output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Feature 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
|
| int64_list_feature |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/create_tf_records_citypersons.py code served (permissive licence) · get_code("f6d735872f4495ed") 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 Feature. 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
# The function expects a 'value' parameter that will be passed to
# tf.train.Int64List(value=value). This should be an iterable of integers.
ARGS = {
"value": [1, 2, 3, 4, 5]
}
- 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 Feature — a Feature output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Feature 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
|
| nms |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/inference_standard_yolov3.py code served (permissive licence) · get_code("7d36f19ae2c4eeb2") 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 EagerTensor, ndim 3, dtype family float, shape (2, 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 tensorflow as tf
class MockModel:
"""Minimal model class that provides the obj_idx attribute used in nms_op."""
def __init__(self, obj_idx=4):
self.obj_idx = obj_idx
# Create a mock model with obj_idx pointing to the confidence score column
model = MockModel(obj_idx=4)
# Create sample boxes tensor
# Shape: (batch_size=2, num_boxes=3, features=5)
# Features: [x1, y1, x2, y2, confidence_score]
# We need boxes with at least 5 columns (4 for coordinates + 1 for confidence at index 4)
all_boxes = tf.constant([
[
[10.0, 20.0, 30.0, 40.0, 0.9],
[15.0, 25.0, 35.0, 45.0, 0.8],
[12.0, 22.0, 32.0, 42.0, 0.7],
],
[
[50.0, 60.0, 70.0, 80.0, 0.95],
[55.0, 65.0, 75.0, 85.0, 0.85],
[52.0, 62.0, 72.0, 82.0, 0.75],
]
], dtype=tf.float32)
ARGS = {
"all_boxes": all_boxes,
"model": model,
}
- 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 EagerTensor, ndim 3, dtype family float, shape (2, 2, 5) — shape (2, 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
|
| nms |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/inference_epistemic.py code served (permissive licence) · get_code("2211cad211bfdc92") 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 EagerTensor, ndim 2, dtype family float, 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 tensorflow as tf
import numpy as np
# Create a small stand-in model class
class MockModel:
def __init__(self):
self.obj_idx = 4 # Index for objectness scores in boxes tensor
model = MockModel()
# Create boxes tensor: shape [2, 5]
# First 4 columns are box coordinates, 5th column is objectness score
boxes_data = np.array([
[10.0, 20.0, 30.0, 40.0, 0.9],
[15.0, 25.0, 35.0, 45.0, 0.8]
], dtype=np.float32)
boxes = tf.constant(boxes_data)
ARGS = {
"boxes": boxes,
"model": model
}
- 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 EagerTensor, ndim 2, dtype family float, 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
|
| split_detection |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/lib_yolo/layers.py code served (permissive licence) · get_code("05a04abe14c59884") 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 tensorflow as tf
# The function splits detection outputs into localization, objectness, and class predictions
# It expects:
# - inputs: a tensor with shape (batch, ..., boxes_per_cell * (4 + 1 + cls_cnt))
# - boxes_per_cell: number of boxes per cell (integer)
# - cls_cnt: number of classes (integer)
# Create a small batch of detection data
# Shape: (batch_size=2, spatial_dim=3, total_features=boxes_per_cell * (4 + 1 + cls_cnt))
batch_size = 2
spatial_dim = 3
boxes_per_cell = 2
cls_cnt = 5
# Total features per location = boxes_per_cell * (4 loc + 1 obj + cls_cnt)
total_features = boxes_per_cell * (4 + 1 + cls_cnt)
# Create input tensor with shape (batch_size, spatial_dim, total_features)
inputs = tf.random.normal([batch_size, spatial_dim, total_features])
ARGS = {
'inputs': inputs,
'boxes_per_cell': boxes_per_cell,
'cls_cnt': cls_cnt
}
- 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 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
|
| split_detection_aleatoric |
Ran ran on a synthesized input |
flkraus/bayesian-yolov3/lib_yolo/layers.py code served (permissive licence) · get_code("5bde5713476f5229") 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 tensorflow as tf
# Set random seed for reproducibility
tf.random.set_seed(0)
# Define the arguments for split_detection_aleatoric
# The function expects:
# - inputs: a tensor that will be split by boxes_per_cell
# - boxes_per_cell: number of boxes per cell (determines first split)
# - cls_cnt: number of classes
# Each box detection has: 4 (loc) + 4 (log_loc_var) + 1 (obj) + 1 (log_obj_stddev) + cls_cnt (cls) + cls_cnt (log_cls_stddev)
# Total per box = 4 + 4 + 1 + 1 + cls_cnt + cls_cnt = 10 + 2*cls_cnt
boxes_per_cell = 2
cls_cnt = 3
# Per-box feature size
per_box_size = 4 + 4 + 1 + 1 + cls_cnt + cls_cnt # = 16
# Total last dimension = boxes_per_cell * per_box_size
total_last_dim = boxes_per_cell * per_box_size # = 32
# Create a small batch of inputs
# Shape: [batch_size, height, width, total_last_dim] or just [batch_size, total_last_dim]
# Using a simple 2D input for clarity: [batch_size, feature_dim]
batch_size = 2
inputs = tf.random.normal([batch_size, total_last_dim])
ARGS = {
'inputs': inputs,
'boxes_per_cell': boxes_per_cell,
'cls_cnt': cls_cnt
}
- 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 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
|
| aleatoric_obj_loss |
Not yet run unverified (harvested, no recorded run) |
flkraus/bayesian-yolov3/lib_yolo/layers.py code served (permissive licence) · get_code("8b895c78336b61c6") How it ran |
| load_darknet_weights |
Not yet run unverified (harvested, no recorded run) |
flkraus/bayesian-yolov3/lib_yolo/darknet.py code served (permissive licence) · get_code("281d23c0cd732c87") How it ran |