SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1805.00907 · 2018

Glow: Graph Lowering Compiler Techniques for Neural Networks

arXiv · PDF · Open in the Atlas

Code that ran

15 of 18 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 12 have no contract verdict; 3 failures of our instrument; 3 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1805.00907.json · badge: /api/ran/1805.00907.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
pytorch/glow canonical (classifier label)
classifier basis: census
15 ran · 3 no recorded run
FunctionStatusWhere it lives
center_crop Ran
ran on a synthesized input
pytorch/glow/torch_glow/utils/torchvision_fake/transforms.py
code served (permissive licence) · get_code("da366058f867300e")
How it ran

Ran 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 Image. 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.

from PIL import Image
import numbers

# Create a small PIL Image for testing
# Create a 10x8 RGB image (width=10, height=8)
img = Image.new('RGB', (10, 8), color='red')

# Define output_size as a number
output_size = 4

ARGS = {
    'img': img,
    'output_size': output_size
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
conv1x1 Ran
ran; our contract draft was wrong, not the code
pytorch/glow/torch_glow/utils/torchvision_fake/resnet.py
code served (permissive licence) · get_code("d9def42110729a85")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Conv2d. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# The function conv1x1 takes in_planes, out_planes, and stride as parameters
# It returns an nn.Conv2d layer configured for 1x1 convolution
# We need to provide valid integer arguments for these parameters

ARGS = {
    "in_planes": 3,
    "out_planes": 64,
    "stride": 1
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
conv3x3 Ran
ran; our contract draft was wrong, not the code
pytorch/glow/torch_glow/utils/torchvision_fake/resnet.py
code served (permissive licence) · get_code("160bb14bd76201b4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned Conv2d. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "in_planes": 3,
    "out_planes": 64,
    "stride": 1,
    "groups": 1,
    "dilation": 1,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Conv2d — a Conv2d output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Conv2d 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
crop Ran
ran; our contract draft was wrong, not the code
pytorch/glow/torch_glow/utils/torchvision_fake/transforms.py
code served (permissive licence) · get_code("a9bbaa08e7827857")
How it ran

Ran 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 Image. 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.

from PIL import Image

# Create a small PIL Image for testing
img = Image.new('RGB', (10, 8), color=(255, 0, 0))

# Define crop parameters
i = 1  # top coordinate
j = 2  # left coordinate
h = 4  # height
w = 5  # width

ARGS = {
    'img': img,
    'i': i,
    'j': j,
    'h': h,
    'w': w
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
default_image_loader Ran
ran on a synthesized input
pytorch/glow/utils/imagenet_topk_accuracy_driver.py
code served (permissive licence) · get_code("984e14405e6a25ef")
How it ran

Ran 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 Image. 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 tempfile
import os
from PIL import Image as PILImage
import torchvision

# Create a temporary directory and a test image file
temp_dir = tempfile.mkdtemp()
test_image_path = os.path.join(temp_dir, "test_image.png")

# Create a simple RGB image and save it
img = PILImage.new('RGB', (10, 10), color='red')
img.save(test_image_path)

ARGS = {
    'path': test_image_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, accimage, torchvision — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
find_all_related_transformation Ran
ran on a synthesized input
pytorch/glow/utils/compilation_filter.py
code served (permissive licence) · get_code("773d008cb657aa60")
How it ran

Ran 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 sqlite3
import tempfile
import os

# Create a temporary SQLite database with the required schema and test data
temp_db = tempfile.NamedTemporaryFile(delete=False, suffix='.db')
temp_db.close()
db_path = temp_db.name

conn = sqlite3.connect(db_path)
cursor = conn.cursor()

# Create the Log_Transformation table
cursor.execute("""
    CREATE TABLE Log_Transformation (
        trans_id TEXT,
        node_name TEXT,
        operation_type TEXT
    )
""")

# Insert test data
test_data = [
    ('1', 'node_A', 'ADD_OPERAND'),
    ('2', 'node_A', 'REMOVE_OPERAND'),
    ('3', 'node_B', 'ADD_OPERAND'),
    ('4', 'node_C', 'OTHER_OP'),
    ('5', 'node_B', 'REMOVE_OPERAND'),
    ('6', 'node_D', 'ADD_OPERAND'),
]

cursor.executemany("""
    INSERT INTO Log_Transformation (trans_id, node_name, operation_type)
    VALUES (?, ?, ?)
""", test_data)

conn.commit()

# Create a fresh cursor for the function call
cursor = conn.cursor()

# Define the arguments
ARGS = {
    'cursor': cursor,
    'transIDs': ['1', '2', '3']
}
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 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
find_all_replaced_nodes Ran
ran on a synthesized input
pytorch/glow/utils/log_parser.py
code served (permissive licence) · get_code("2d9bd71d8d47b863")
How it ran

Ran 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 typing
from typing import Dict, List, Tuple

class NodeNameAndKind(typing.NamedTuple):
    """A class that represents the named tuple of node name and kind."""
    name: str
    kind: str

class NodeValue(typing.NamedTuple):
    """A class that represents the named tuple of node and result number."""
    node: 'Node'
    resNo: int

class Node:
    """A class that represents a node in the compute graph

    Public attributes:
        kindName_: str. The kind name.
        name_: str. The node name.
        inputs_: List[NodeValue]. Input node values.
        users_: Dict['Node', int]. The users of this node.
    """

    def __init__(self, kindName: str, name: str):
        self.kindName_: str = kindName
        self.name_: str = name
        self.inputs_: List[NodeValue] = []
        self.users_: Dict['Node', int] = {}

    def __repr__(self):
        return self.name_

    def get_kind_name(self) -> str:
        """Gets the kind name."""
        return self.kindName_

    def get_name(self) -> str:
        """Gets the node name."""
        return self.name_

    def getNodeNameAndKind(self) -> NodeNameAndKind:
        """Gets the Name+Kind tuple."""
        return (self.name_, self.kindName_)

    def get_inputs(self) -> List[NodeValue]:
        """Gets the input node."""
        return self.inputs_

    def get_users(self) -> Dict['Node', int]:
        """Gets the user of this node."""
        return self.users_

    def add_user(self, u: 'Node') -> None:
        """Adds one user of this node. Increment the number of uses of the user by 1."""
        if u not in self.users_:
            self.users_[u] = 0
        self.users_[u] += 1

    def remove_user(self, u: 'Node') -> None:
        """Removes one use from the given user."""
        if u in self.users_:
            self.users_[u] -= 1
            if self.users_[u] == 0:
                del self.users_[u]

    def has_no_uses(self) -> bool:
        """Returns True if the node has no uses."""
        return len(self.users_) == 0

    def set_input(self, nodeVal: NodeValue) -> None:
        """Adds one input node value."""
        self.inputs_.append(nodeVal)

    def replace_input(self, oldNodeVal: NodeValue, newNodeVal: NodeValue) -> None:
        """Replace one operand with another one.

        Args:
            oldNode: Node. Old operand node.
            oldResNo: int. Old operand result number.
            newNode: Node. New operand node.
            newResNo: int. New operand result number.
        """
        try:
            self.inputs_.remove(oldNodeVal)
        except ValueError:
            print("Removed input value must already exist in the node's input list. ")
        self.inputs_.append(newNodeVal)

    def set_scope_of_creation(self, creationScopeName: str) -> None:
        self.creationScopeName_ = creationScopeName


# Create a small graph to test the function
# Graph structure:
# node_a -> node_b -> node_d
# node_a -> node_c -> node_d
# node_d has no users initially

node_a = Node("constant", "a")
node_b = Node("add", "b")
node_c = Node("mul", "c")
node_d = Node("concat", "d")

# Set up inputs: b and c both depend on a
node_b.set_input(NodeValue(node_a, 0))
node_c.set_input(NodeValue(node_a, 0))

# Set up inputs: d depends on b and c
node_d.set_input(NodeValue(node_b, 0))
node_d.set_input(NodeValue(node_c, 0))

# Set up users: a has two users (b and c), b and c each have one user (d)
node_a.add_user(node_b)
node_a.add_user(node_c)
node_b.add_user(node_d)
node_c.add_user(node_d)

# node_d starts with no users
# When we call find_all_replaced_nodes(node_d), it should traverse backwards
# and identify nodes that will lose all their users

ARGS = {
    "replacedNode": node_d
}
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 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
init_db Ran
ran on a synthesized input
pytorch/glow/utils/compilation_filter.py
code served (permissive licence) · get_code("488f6fd3326fd5ca")
How it ran

Ran 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 Connection. 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 os
import sqlite3
import tempfile

# Create a temporary SQLite database file
with tempfile.NamedTemporaryFile(mode='w', suffix='.db', delete=False) as f:
    temp_db_path = f.name

# Initialize the database file so it exists
conn = sqlite3.connect(temp_db_path)
conn.close()

# Define arguments for init_db
ARGS = {
    'sqliteFile': temp_db_path
}
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 Connection — a Connection output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Connection 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
init_db Ran
ran on a synthesized input
pytorch/glow/utils/log_parser.py
code served (permissive licence) · get_code("ad72ce9123a98a26")
How it ran

Ran 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 Connection. 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 os
import sqlite3
import tempfile

# Create a temporary directory for the database file
temp_dir = tempfile.mkdtemp()
sqlite_file = os.path.join(temp_dir, "test_db.sqlite")

ARGS = {
    "sqliteFile": sqlite_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 Connection — a Connection output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Connection 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
mode_0to1 Ran
ran on a synthesized input
pytorch/glow/utils/caffe2_pb_runner.py
code served (permissive licence) · get_code("58d65437202272b5")
How it ran

Ran 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 numpy as np

torch.manual_seed(0)

# The function mode_0to1 takes a single parameter x and divides it by 255
# x should be a tensor or array-like object that supports division
x = torch.tensor([[0.0, 85.0, 170.0, 255.0],
                   [25.5, 51.0, 127.5, 204.0]], dtype=torch.float32)

ARGS = {
    "x": x
}
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 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
mode_0to256 Ran
ran on a synthesized input
pytorch/glow/utils/caffe2_pb_runner.py
code served (permissive licence) · get_code("75c98dd70e687f49")
How it ran

Ran 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 numpy as np

torch.manual_seed(0)

# The function mode_0to256(x) simply returns x as-is
# So x can be any value - let's use a small tensor
x = torch.randn(2, 4)

ARGS = {
    "x": x
}
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 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
mode_128to127 Ran
ran on a synthesized input
pytorch/glow/utils/caffe2_pb_runner.py
code served (permissive licence) · get_code("5b3e7d8d033563ff")
How it ran

Ran 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 numpy as np

torch.manual_seed(0)

# The function mode_128to127 takes a single parameter x and subtracts 128 from it
# x should be a numeric value or tensor that supports subtraction

x = torch.tensor([[1.0, 2.0, 3.0, 4.0],
                  [5.0, 6.0, 7.0, 8.0]])

ARGS = {
    'x': x
}
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 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
pickle_load Ran
ran on a synthesized input
pytorch/glow/utils/download_datasets_and_models.py
code served (permissive licence) · get_code("0b1b9afe65c79f72")
How it ran

Ran 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 sys
import io

# Create a small pickle file in memory
data = {'key': 'value', 'number': 42}
pickle_bytes = pickle.dumps(data)
file_obj = io.BytesIO(pickle_bytes)

ARGS = {
    'file': file_obj
}
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
pil_loader Ran
ran on a synthesized input
pytorch/glow/utils/imagenet_topk_accuracy_driver.py
code served (permissive licence) · get_code("397bf3e58cfadb47")
How it ran

Ran 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 Image. 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 PIL.Image as Image
import io
import numpy as np

# Create a small RGB image in memory
img_array = np.random.randint(0, 256, (10, 10, 3), dtype=np.uint8)
pil_img = Image.fromarray(img_array, mode='RGB')

# Save to bytes buffer
buffer = io.BytesIO()
pil_img.save(buffer, format='PNG')
buffer.seek(0)

# Write to a temporary file path (we'll use a string path)
import tempfile
import os

temp_dir = tempfile.gettempdir()
temp_path = os.path.join(temp_dir, 'test_image.png')

with open(temp_path, 'wb') as f:
    f.write(buffer.getvalue())

ARGS = {
    'path': temp_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
resize Ran
ran on a synthesized input
pytorch/glow/torch_glow/utils/torchvision_fake/transforms.py
code served (permissive licence) · get_code("59659f8793b5e227")
How it ran

Ran 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 Image. 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.

from PIL import Image
from collections.abc import Iterable

# Create a small PIL Image for testing
img = Image.new('RGB', (100, 150))

# Test case 1: resize with integer size
size_int = 50

# Test case 2: resize with tuple size (height, width)
size_tuple = (75, 100)

# Interpolation mode
interpolation = Image.BILINEAR

ARGS = {
    'img': img,
    'size': size_int,
    'interpolation': interpolation
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
PIL — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Image — a Image output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Image output the recorded ndim 3 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
accimage_loader Not yet run
unverified (harvested, no recorded run)
pytorch/glow/utils/imagenet_topk_accuracy_driver.py
code served (permissive licence) · get_code("c6a6d592fac4207a")
How it ran

no invocation recorded.

filter_node_transformation Not yet run
unverified (harvested, no recorded run)
pytorch/glow/utils/compilation_filter.py
code served (permissive licence) · get_code("7e0e0f3068610ef4")
How it ran

no invocation recorded.

resnet18 Not yet run
unverified (harvested, no recorded run)
pytorch/glow/torch_glow/utils/torchvision_fake/resnet.py
code served (permissive licence) · get_code("3f0a356e3f033e3a")
How it ran

no invocation recorded.

Also present in other papers' code

Of 18 samples lifted from this paper's linked repositories, 18 carry a function identity and 0 do not. Of the 18 distinct functions with an identity, 5 are also present in other papers whose code we hold (3 with at least one paper dated earlier, 0 the same month, 5 later) and 13 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
conv1x1 431 other papers
15 dated earlier, 415 later, 1 undated · 38 only as an assembly brick
1409.1556 (2014-09)
Very Deep Convolutional Networks for Large-Scale Image Recognition
1506.01186 (2015-06)
Cyclical Learning Rates for Training Neural Networks
1507.05717 (2015-07)
An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition
and 428 more not named here
conv3x3 312 other papers
7 dated earlier, 304 later, 1 undated · 31 only as an assembly brick
1409.1556 (2014-09)
Very Deep Convolutional Networks for Large-Scale Image Recognition
1507.05717 (2015-07)
An End-to-End Trainable Neural Network for Image-based Sequence Recognition and Its Application to Scene Text Recognition
1512.03385 (2015-12)
Deep Residual Learning for Image Recognition
and 309 more not named here
resnet18 95 other papers
94 later, 1 undated
1902.08153 (2019-02)
Learned Step Size Quantization
1904.01355 (2019-04)
FCOS: Fully Convolutional One-Stage Object Detection
1911.06487 (2019-11)
OpenLORIS-Object: A Robotic Vision Dataset and Benchmark for Lifelong Deep Learning
and 92 more not named here
accimage_loader 39 other papers
2 dated earlier, 37 later
1702.00758 (2017-02)
HashNet: Deep Learning to Hash by Continuation
1711.02512 (2017-11)
Fine-tuning CNN Image Retrieval with No Human Annotation
1907.02665 (2019-07)
Blind Image Quality Assessment Using A Deep Bilinear Convolutional Neural Network
and 36 more not named here
crop 2 other papers
2 later
1906.06423 (2019-06)
Fixing the train-test resolution discrepancy
2401.02031 (2024-01)
Spy-Watermark: Robust Invisible Watermarking for Backdoor Attack

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

This paper presents the design of Glow, a machine learning compiler for heterogeneous hardware. It is a pragmatic approach to compilation that enables the generation of highly optimized code for multiple targets. Glow lowers the traditional neural network dataflow graph into a two-phase strongly-typed intermediate representation. The high-level intermediate representation allows the optimizer to perform domain-specific optimizations. The lower-level instruction-based address-only intermediate representation allows the compiler to perform memory-related optimizations, such as instruction scheduling, static memory allocation and copy elimination. At the lowest level, the optimizer performs machine-specific code generation to take advantage of specialized hardware features. Glow features a lowering phase which enables the compiler to support a high number of input operators as well as a large number of hardware targets by eliminating the need to implement all operators on all targets. The lowering phase is designed to reduce the input space and allow new hardware backends to focus on a small number of linear algebra primitives.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1805.00907")
get_code_for_paper("1805.00907")
have("1805.00907")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1805.00907.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1805.00907.svg)](https://syntology.ai/paper/1805.00907)

Connect an agent — have() is free.