SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2210.08465 · EMNLP · 2022

Character-Centric Story Visualization via Visual Planning and Token Alignment

Nanyun Peng, Hong Chen, Te-Lin Wu, Rujun Han, Hideki Nakayama

arXiv · PDF · Open in the Atlas

Code that ran

12 of 21 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (7 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 8 have no contract verdict; 3 failures of our instrument; 9 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/2210.08465.json · badge: /api/ran/2210.08465.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
adymaharana/VLCStoryGan community
Papers with Code archive
12 ran · 9 no recorded run
FunctionStatusWhere it lives
BertEmbeddings Ran
ran on a synthesized input · constructed an object; no result was computed
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("79728760d660d983")
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 an instance of its own class, BertEmbeddings: the run constructed the object and did not call it, so no result was computed. 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
import math

torch.manual_seed(0)

class Config:
    """Minimal config class with required attributes"""
    def __init__(self):
        self.vocab_size = 100
        self.word_vec_size = 4
        self.hidden_size = 8
        self.layer_norm_eps = 1e-12
        self.hidden_dropout_prob = 0.1
        self.max_position_embeddings = 50

config = Config()

ARGS = {
    "config": config,
    "add_postion_embeddings": True
}
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 BertEmbeddings — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a BertEmbeddings 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
BertIntermediate Ran
ran on a synthesized input · constructed an object; no result was computed
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("455739c5ad6b2387")
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 an instance of its own class, BertIntermediate: the run constructed the object and did not call it, so no result was computed. 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
import math

torch.manual_seed(0)

# Create a minimal config class with required attributes
class BertConfig:
    def __init__(self):
        self.hidden_size = 4
        self.intermediate_size = 3

config = BertConfig()

ARGS = {
    "config": config
}
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 BertIntermediate — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a BertIntermediate 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
DynamicFilterLayer Ran
ran on a synthesized input · constructed an object; no result was computed
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("a8ea3a32f7622e56")
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 an instance of its own class, DynamicFilterLayer: the run constructed the object and did not call it, so no result was computed. 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 on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import numpy as np

torch.manual_seed(0)

ARGS = {
    'filter_size': (3, 3),
    'stride': (1, 1),
    'pad': (1, 1),
    'flip_filters': False,
    'grouping': False
}
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 DynamicFilterLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DynamicFilterLayer 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
LxmertAttention Ran
ran on a synthesized input · constructed an object; no result was computed
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("118186316f75b11b")
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 an instance of its own class, LxmertAttention: the run constructed the object and did not call it, so no result was computed. 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
import math

class LxmertAttention(nn.Module):

    def __init__(self, hidden_size, num_attention_heads, attention_probs_dropout_prob, ctx_dim=None):
        super().__init__()
        if hidden_size % num_attention_heads != 0:
            raise ValueError('The hidden size (%d) is not a multiple of the number of attention heads (%d)' % (hidden_size, num_attention_heads))
        self.num_attention_heads = num_attention_heads
        self.attention_head_size = int(hidden_size / num_attention_heads)
        self.head_size = self.num_attention_heads * self.attention_head_size
        if ctx_dim is None:
            ctx_dim = hidden_size
        self.query = nn.Linear(hidden_size, self.head_size)
        self.key = nn.Linear(ctx_dim, self.head_size)
        self.value = nn.Linear(ctx_dim, self.head_size)
        self.dropout = nn.Dropout(attention_probs_dropout_prob)

    def transpose_for_scores(self, x):
        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
        x = x.view(*new_x_shape)
        return x.permute(0, 2, 1, 3)

    def forward(self, hidden_states, context, attention_mask=None, output_attentions=False):
        mixed_query_layer = self.query(hidden_states)
        mixed_key_layer = self.key(context)
        mixed_value_layer = self.value(context)
        query_layer = self.transpose_for_scores(mixed_query_layer)
        key_layer = self.transpose_for_scores(mixed_key_layer)
        value_layer = self.transpose_for_scores(mixed_value_layer)
        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
        if attention_mask is not None:
            attention_mask = attention_mask.unsqueeze(1).unsqueeze(1).repeat(1, attention_scores.shape[1], attention_scores.shape[2], 1)
            attention_scores.data.masked_fill_(attention_mask.data > 0, -float('inf'))
        attention_probs = nn.Softmax(dim=-1)(attention_scores)
        attention_probs = self.dropout(attention_probs)
        context_layer = torch.matmul(attention_probs, value_layer)
        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
        new_context_layer_shape = context_layer.size()[:-2] + (self.head_size,)
        context_layer = context_layer.view(*new_context_layer_shape)
        outputs = (context_layer, attention_probs) if output_attentions else (context_layer,)
        return outputs

torch.manual_seed(0)

hidden_size = 8
num_attention_heads = 2
attention_probs_dropout_prob = 0.1
ctx_dim = 12

attention_module = LxmertAttention(
    hidden_size=hidden_size,
    num_attention_heads=num_attention_heads,
    attention_probs_dropout_prob=attention_probs_dropout_prob,
    ctx_dim=ctx_dim
)

batch_size = 2
seq_length = 3
ctx_length = 5

hidden_states = torch.randn(batch_size, seq_length, hidden_size)
context = torch.randn(batch_size, ctx_length, ctx_dim)
attention_mask = torch.zeros(batch_size, ctx_length, dtype=torch.long)

ARGS = {
    'hidden_size': hidden_size,
    'num_attention_heads': num_attention_heads,
    'attention_probs_dropout_prob': attention_probs_dropout_prob,
    'ctx_dim': ctx_dim
}
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 LxmertAttention — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a LxmertAttention 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
LxmertAttentionOutput Ran
ran on a synthesized input
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("37566e964d58aad9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, 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

# INIT_ARGS: parameters for LxmertAttentionOutput.__init__
INIT_ARGS = {
    'hidden_size': 8,
    'hidden_dropout_prob': 0.1
}

# ARGS: parameters for LxmertAttentionOutput.forward
ARGS = {
    'hidden_states': torch.randn(2, 5, 8),  # batch_size=2, seq_len=5, hidden_size=8
    'input_tensor': torch.randn(2, 5, 8)     # batch_size=2, seq_len=5, hidden_size=8
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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 3, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
MartPooler Ran
ran on a synthesized input · constructed an object; no result was computed
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("f5111c56952b1ddc")
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 an instance of its own class, MartPooler: the run constructed the object and did not call it, so no result was computed. 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)

# Analyze the forward method to understand what's needed:
# - input_states: used with .shape[0], .transpose(1, 2), * operator, .sum()
#   Expected shape: (batch_size, seq_len, input_size)
# - mask: used with .float(), [:, :, None], .unsqueeze(-1), .repeat()
#   Expected shape: (batch_size, seq_len)
# - context_vector: shape (1, 1, input_size)
# - The fc layer takes pooled_output and processes it

batch_size = 2
seq_len = 5
input_size = 4
output_size = 3

# Create input_states tensor: (batch_size, seq_len, input_size)
input_states = torch.randn(batch_size, seq_len, input_size)

# Create mask tensor: (batch_size, seq_len)
# Mask should be binary (0 or 1) to indicate valid positions
mask = torch.ones(batch_size, seq_len)
mask[0, 3:] = 0  # Mask out last 2 positions in first sample
mask[1, 4:] = 0  # Mask out last position in second sample

ARGS = {
    'input_size': input_size,
    'output_size': output_size,
    'mode': 'attention'
}
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 MartPooler — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MartPooler 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
PositionEncoding Ran
ran on a synthesized input · constructed an object; no result was computed
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("b6f03dfe01742a92")
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 an instance of its own class, PositionEncoding: the run constructed the object and did not call it, so no result was computed. 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
import math

torch.manual_seed(0)

# Setup arguments for PositionEncoding
ARGS = {
    'n_filters': 128,
    'max_len': 500
}
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 PositionEncoding — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PositionEncoding 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
ResBlock Ran
ran on a synthesized input · constructed an object; no result was computed
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("d434aa3ac7f6993a")
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 an instance of its own class, ResBlock: the run constructed the object and did not call it, so no result was computed. 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 = {
    "channel_num": 4
}
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 ResBlock — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ResBlock 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
gelu Ran
ran, honoured the contract we drafted
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("a3abf3fe697fabd0")
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 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 math

torch.manual_seed(0)

# The gelu function takes a single parameter 'x' which should be a tensor
# The function applies element-wise operations: multiplication, addition, torch.erf, division
# So x should be a torch.Tensor

x = torch.randn(2, 4)

ARGS = {
    "x": x
}
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 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
make_pad_shifted_mask Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("93af85ca91baf7b0")
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 3, dtype family float, shape (2, 5, 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

torch.manual_seed(0)

# Construct input_mask as a 2D tensor with shape (batch_size, seq_len)
# batch_size = 2, seq_len = max_v_len + max_t_len + memory_len
max_v_len = 2
max_t_len = 3
memory_len = 0

seq_len = max_v_len + max_t_len + memory_len  # 5

# Create input_mask with 1s indicating valid positions
input_mask = torch.ones(2, seq_len)

ARGS = {
    "input_mask": input_mask,
    "max_v_len": max_v_len,
    "max_t_len": max_t_len,
    "memory_len": memory_len,
}
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 3, dtype family float, shape (2, 5, 5) — shape (2, 5, 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
make_shifted_mask Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("cd0b5f41868c631f")
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 3, dtype family float, shape (2, 5, 6) 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

torch.manual_seed(0)

# Construct input_mask: (N, L) with 1s for valid, 0s for pad
# We need L = max_v_len + max_t_len + memory_len
max_v_len = 2
max_t_len = 3
memory_len = 1
seq_len = max_v_len + max_t_len + memory_len  # 2 + 3 + 1 = 6

bsz = 2
input_mask = torch.ones(bsz, seq_len)

ARGS = {
    "input_mask": input_mask,
    "max_v_len": max_v_len,
    "max_t_len": max_t_len,
    "memory_len": memory_len,
}
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 3, dtype family float, shape (2, 5, 6) — shape (2, 5, 6) 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
upBlock Ran
ran; our contract draft was wrong, not the code
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("721bc7234edf9845")
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 Sequential. 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,
}
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 Sequential — a Sequential output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a Sequential output the recorded ndim 1 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
BertAttention Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("7758e2dc60da7479")
How it ran

no invocation recorded.

BertEncoderWithMemory Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("38a29e27a1641775")
How it ran

no invocation recorded.

BertLayerWithMemory Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("3b66ce72af6145fa")
How it ran

no invocation recorded.

BertSelfAttention Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("e5006dcf91e21556")
How it ran

no invocation recorded.

CA_NET Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("99751ef923ab069c")
How it ran

no invocation recorded.

MemoryUpdater Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("44aa26a7f2f9a571")
How it ran

no invocation recorded.

NEXT_STAGE_G Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("b72cbd35cd593c73")
How it ran

no invocation recorded.

StoryMartGAN Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("eddb0906b50d313d")
How it ran

no invocation recorded.

make_video_only_mask Not yet run
unverified (harvested, no recorded run)
adymaharana/VLCStoryGan/vlcgan/model.py
code served (permissive licence) · get_code("4b14e2379269d142")
How it ran

no invocation recorded.

Also present in other papers' code

Of 21 samples lifted from this paper's linked repositories, 21 carry a function identity and 0 do not. Of the 21 distinct functions with an identity, 6 are also present in other papers whose code we hold (6 with at least one paper dated earlier, 1 the same month, 5 later) and 15 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
gelu
brick of this paper's assembly: helper
198 other papers
118 dated earlier, 4 the same month, 72 later, 4 same year, order not determinable · 32 only as an assembly brick
1408.5882 (2014-08)
Convolutional Neural Networks for Sentence Classification
1810.04805 (2018-10)
BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding
1901.10125 (2019-01)
Glyce: Glyph-vectors for Chinese Character Representations
and 195 more not named here
BertAttention
brick of this paper's assembly: helper
3 other papers
2 dated earlier, 1 later · 1 only as an assembly brick
2005.05402 (2020-05)
MART: Memory-Augmented Recurrent Transformer for Coherent Video Paragraph Captioning
2108.00061 (2021-08)
MTVR: Multilingual Moment Retrieval in Videos
2603.05969 (2026-03)
Imagine How To Change: Explicit Procedure Modeling for Change Captioning
BertIntermediate
brick of this paper's assembly: helper
3 other papers
2 dated earlier, 1 later · 2 only as an assembly brick
2005.05402 (2020-05)
MART: Memory-Augmented Recurrent Transformer for Coherent Video Paragraph Captioning
2203.14040 (2022-03)
Visual Abductive Reasoning
2603.05969 (2026-03)
Imagine How To Change: Explicit Procedure Modeling for Change Captioning
PositionEncoding
brick of this paper's assembly: helper
3 other papers
2 dated earlier, 1 later · 1 only as an assembly brick
2005.05402 (2020-05)
MART: Memory-Augmented Recurrent Transformer for Coherent Video Paragraph Captioning
2005.06409 (2020-05)
Dense-Caption Matching and Frame-Selection Gating for Temporal Localization in VideoQA
2603.05969 (2026-03)
Imagine How To Change: Explicit Procedure Modeling for Change Captioning
upBlock
brick of this paper's assembly: model
3 other papers
3 dated earlier
1710.10916 (2017-10)
StackGAN++: Realistic Image Synthesis with Stacked Generative Adversarial Networks
1910.13321 (2019-10)
Semantic Object Accuracy for Generative Text-to-Image Synthesis
2105.10026 (2021-05)
Improving Generation and Evaluation of Visual Stories via Semantic Consistency
BertEncoderWithMemory
brick of this paper's assembly: helper
2 other papers
1 dated earlier, 1 later · 1 only as an assembly brick
2005.05402 (2020-05)
MART: Memory-Augmented Recurrent Transformer for Coherent Video Paragraph Captioning
2603.05969 (2026-03)
Imagine How To Change: Explicit Procedure Modeling for Change Captioning

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

Story visualization advances the traditional text-to-image generation by enabling multiple image generation based on a complete story. This task requires machines to 1) understand long text inputs and 2) produce a globally consistent image sequence that illustrates the contents of the story. A key challenge of consistent story visualization is to preserve characters that are essential in stories. To tackle the challenge, we propose to adapt a recent work that augments Vector-Quantized Variational Autoencoders (VQ-VAE) with a text-tovisual-token (transformer) architecture. Specifically, we modify the text-to-visual-token module with a two-stage framework: 1) character token planning model that predicts the visual tokens for characters only; 2) visual token completion model that generates the remaining visual token sequence, which is sent to VQ-VAE for finalizing image generations. To encourage characters to appear in the images, we further train the two-stage framework with a character-token alignment objective. Extensive experiments and evaluations demonstrate that the proposed method excels at preserving characters and can produce higher quality image sequences compared with the strong baselines. Code can be found in https: //github.com/PlusLabNLP/VP-CSV

For agents

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

get_harvested_code_for_paper("2210.08465")
get_code_for_paper("2210.08465")
have("2210.08465")

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

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

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

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

Connect an agent — have() is free.