SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2106.06103 · ICML · 2021

Conditional Variational Autoencoder with Adversarial Learning for End-to-End Text-to-Speech

Jungil Kong, Jaehyeon Kim, Juhee Son

arXiv · PDF · Open in the Atlas

Code that ran

47 of 77 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (12 of them constructed an object rather than computing a result; 3 honoured the contract we drafted, 0 violated it and 23 have no contract verdict; 21 failures of our instrument; 30 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/2106.06103.json · badge: /api/ran/2106.06103.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
jaywalnut310/vits canonical (classifier label)
classifier basis not recorded on the link
8 ran · 3 no recorded run
jaywalnut310/glow-tts canonical (classifier label)
classifier basis: census
7 ran · 2 no recorded run
NVIDIA/tacotron2 canonical (classifier label)
classifier basis: census
2 ran · 4 no recorded run
isletennos/mmvc_trainer community
Papers with Code archive
15 ran · 8 no recorded run
jmp84/vits community
Papers with Code archive
6 ran · 6 no recorded run
wenet-e2e/wetts community (classifier label)
classifier basis not recorded on the link
3 ran · 1 no recorded run
maum-ai/phaseaug community (classifier label)
classifier basis not recorded on the link
3 ran · 0 no recorded run
olawod/freevc community
Papers with Code archive
2 ran · 5 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
p0p4k/vits2_pytorch community (classifier label)
classifier basis not recorded on the link
0 ran · 1 no recorded run
FunctionStatusWhere it lives
DDSConv Ran
ran on a synthesized input · constructed an object; no result was computed
jmp84/vits/models.py
code served (permissive licence) · get_code("f0dbf406caa930d9")
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, DDSConv: 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
from torch import nn

torch.manual_seed(0)

ARGS = {
    "channels": 4,
    "kernel_size": 3,
    "n_layers": 2,
    "p_dropout": 0.1,
}
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 DDSConv — 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 DDSConv 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
DurationPredictor Ran
ran on a synthesized input · constructed an object; no result was computed
jmp84/vits/models.py
code served (permissive licence) · get_code("d2782997a07f6dfc")
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, DurationPredictor: 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
from torch.nn import functional as F

torch.manual_seed(0)

class LayerNorm(nn.Module):
    def __init__(self, channels, eps=1e-05):
        super().__init__()
        self.channels = channels
        self.eps = eps
        self.gamma = nn.Parameter(torch.ones(channels))
        self.beta = nn.Parameter(torch.zeros(channels))

    def forward(self, x):
        x = x.transpose(1, -1)
        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
        return x.transpose(1, -1)

class DurationPredictor(nn.Module):
    def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
        super().__init__()
        self.in_channels = in_channels
        self.filter_channels = filter_channels
        self.kernel_size = kernel_size
        self.p_dropout = p_dropout
        self.gin_channels = gin_channels
        self.drop = nn.Dropout(p_dropout)
        self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size // 2)
        self.norm_1 = LayerNorm(filter_channels)
        self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size // 2)
        self.norm_2 = LayerNorm(filter_channels)
        self.proj = nn.Conv1d(filter_channels, 1, 1)
        if gin_channels != 0:
            self.cond = nn.Conv1d(gin_channels, in_channels, 1)

    def forward(self, x, x_mask, g=None):
        x = torch.detach(x)
        if g is not None:
            g = torch.detach(g)
            x = x + self.cond(g)
        x = self.conv_1(x * x_mask)
        x = torch.relu(x)
        x = self.norm_1(x)
        x = self.drop(x)
        x = self.conv_2(x * x_mask)
        x = torch.relu(x)
        x = self.norm_2(x)
        x = self.drop(x)
        x = self.proj(x * x_mask)
        return x * x_mask


# Create model and test inputs
batch_size = 2
in_channels = 4
filter_channels = 5
kernel_size = 3
p_dropout = 0.1
gin_channels = 6
seq_length = 8

# Input tensor: (batch, in_channels, seq_length)
x = torch.randn(batch_size, in_channels, seq_length)

# Mask tensor: (batch, 1, seq_length)
x_mask = torch.ones(batch_size, 1, seq_length)

# Conditioning tensor (when gin_channels != 0): (batch, gin_channels, seq_length)
g = torch.randn(batch_size, gin_channels, seq_length)

ARGS = {
    "in_channels": in_channels,
    "filter_channels": filter_channels,
    "kernel_size": kernel_size,
    "p_dropout": p_dropout,
    "gin_channels": gin_channels,
}
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 DurationPredictor — 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 DurationPredictor 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
ElementwiseAffine Ran
ran on a synthesized input · constructed an object; no result was computed
jmp84/vits/models.py
code served (permissive licence) · get_code("d6380a9b9627f5fa")
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, ElementwiseAffine: 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
from torch import nn

torch.manual_seed(0)

# Create arguments for ElementwiseAffine.forward()
channels = 4
batch_size = 2

# Create the module
module = nn.Module()
element_wise_affine = nn.Sequential(
    nn.Identity()  # placeholder
)

# Create input tensor: (batch, channels, length)
x = torch.randn(batch_size, channels, 3)

# Create mask tensor: (batch, channels, length)
x_mask = torch.ones(batch_size, channels, 3)

# Test both forward and reverse modes
ARGS = {
    'channels': channels,
}

# Also prepare forward call arguments for testing
FORWARD_ARGS_NORMAL = {
    'x': x,
    'x_mask': x_mask,
    'reverse': False,
}

FORWARD_ARGS_REVERSE = {
    'x': x,
    'x_mask': x_mask,
    'reverse': True,
}

ARGS = {
    'channels': 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 ElementwiseAffine — 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 ElementwiseAffine 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
FFN Ran
ran on a synthesized input · constructed an object; no result was computed
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("105de269bbc6a61f")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Flip Ran
ran on a synthesized input
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("1792455895b131d4")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Generator Ran
ran on a synthesized input · constructed an object; no result was computed
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("ccc7aa1ec0421795")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

LayerNorm Ran
ran on a synthesized input · constructed an object; no result was computed
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("649dfa04ce7522a2")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Log Ran
ran on a synthesized input
jmp84/vits/models.py
code served (permissive licence) · get_code("ecedf3198e3c1020")
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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

class Log(nn.Module):

    def forward(self, x, x_mask, reverse=False, **kwargs):
        if not reverse:
            y = torch.log(torch.clamp_min(x, 1e-05)) * x_mask
            logdet = torch.sum(-y, [1, 2])
            return (y, logdet)
        else:
            x = torch.exp(x) * x_mask
            return x


INIT_ARGS = {}

ARGS = {
    'x': torch.randn(2, 4, 3),
    'x_mask': torch.ones(2, 4, 3),
    'reverse': False
}

if __name__ == '__main__':
    model = Log(**INIT_ARGS)
    output = model(**ARGS)
    print("Forward pass output:", output)
    
    ARGS_reverse = {
        'x': torch.randn(2, 4, 3),
        'x_mask': torch.ones(2, 4, 3),
        'reverse': True
    }
    output_reverse = model(**ARGS_reverse)
    print("Reverse pass output:", output_reverse)
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 tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
MultiHeadAttention Ran
ran on a synthesized input · constructed an object; no result was computed
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("1565e9cf603643df")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ResBlock1 Ran
ran on a synthesized input · constructed an object; no result was computed
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("54658cf2627bb592")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ResBlock2 Ran
ran on a synthesized input · constructed an object; no result was computed
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("054d6a8b9d719923")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

SpeakerEncoder Ran
ran on a synthesized input · constructed an object; no result was computed
olawod/freevc/models.py
code served (permissive licence) · get_code("b35a311435634a3e")
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, SpeakerEncoder: 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
from torch import nn

torch.manual_seed(0)

# The SpeakerEncoder uses:
# - mel_n_channels: input feature dimension for LSTM
# - model_num_layers: number of LSTM layers
# - model_hidden_size: hidden size of LSTM
# - model_embedding_size: output embedding dimension

ARGS = {
    "mel_n_channels": 80,
    "model_num_layers": 3,
    "model_hidden_size": 256,
    "model_embedding_size": 256,
}
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 SpeakerEncoder — 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 SpeakerEncoder 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
WN Ran
ran on a synthesized input · constructed an object; no result was computed
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("c95240fe5270874a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

WN Ran
ran on a synthesized input · constructed an object; no result was computed
olawod/freevc/models.py
code served (permissive licence) · get_code("0b63f8b32a435c7e")
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, WN: 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
from torch import nn

torch.manual_seed(0)

# Setup parameters for WN class
hidden_channels = 4
kernel_size = 3
dilation_rate = 2
n_layers = 2
gin_channels = 8
p_dropout = 0.1

ARGS = {
    "hidden_channels": hidden_channels,
    "kernel_size": kernel_size,
    "dilation_rate": dilation_rate,
    "n_layers": n_layers,
    "gin_channels": gin_channels,
    "p_dropout": p_dropout,
}
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 WN — 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 WN 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
collate_fn Ran
ran on a synthesized input
wenet-e2e/wetts/wetts/frontend/dataset.py
code served (permissive licence) · get_code("4d1471c10a3510b7")
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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

class StandInTokenizer:
    def __call__(self, sentences, padding=True, truncation=True, is_split_into_words=True, return_tensors='pt'):
        # sentences is a list of sentences (which are lists of words)
        # Return a dict with 'input_ids' key containing a tensor
        max_len = max(len(s) + 2 for s in sentences) if sentences else 4
        batch_size = len(sentences)
        input_ids = torch.ones((batch_size, max_len), dtype=torch.long)
        for idx, sent in enumerate(sentences):
            # First token is special (like [CLS]), then words, then padding
            input_ids[idx, 0] = 101  # [CLS] token
            for word_idx, word in enumerate(sent):
                input_ids[idx, word_idx + 1] = 100 + word_idx
        return {'input_ids': input_ids}

batch_samples = [
    {
        'sentence': ['hello', 'world'],
        'polyphones': [1, 2],
        'prosody': [3, 4]
    },
    {
        'sentence': ['foo', 'bar'],
        'polyphones': [2, 1],
        'prosody': [4, 3]
    }
]

tokenizer = StandInTokenizer()

ARGS = {
    'batch_samples': batch_samples,
    'tokenizer': tokenizer
}
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 tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_pad_shape Ran
ran, honoured the contract we drafted
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("59ae0708b1e8d94b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

cosine_similarity Ran
ran on a synthesized input
wenet-e2e/wetts/wetts/frontend/export_onnx.py
code served (permissive licence) · get_code("2aa92e480638a500")
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 float, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create two small tensors with distinct shapes for clarity
tensor1 = torch.randn(2, 4)  # batch=2, features=4
tensor2 = torch.randn(2, 4)  # batch=2, features=4

ARGS = {
    "tensor1": tensor1,
    "tensor2": tensor2,
}
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 float, ndim 0, dtype family float, shape () — shape () 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
discriminator_loss Ran
ran; our contract draft was wrong, not the code
jaywalnut310/vits/losses.py
pointer only (licence: MIT); the stored copy get_code serves, from wxzyd123/pivotal_objective_perturbation, is pointer only (licence: NONE) · get_code("896f7aae82a62114")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from wxzyd123/pivotal_objective_perturbation, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

discriminator_loss Ran
ran on a synthesized input
maum-ai/phaseaug/models.py
code served (permissive licence) · get_code("9aa5905b881a121c")
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 tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function expects two parameters:
# - disc_real_outputs: iterable of tensors (discriminator outputs for real data)
# - disc_generated_outputs: iterable of tensors (discriminator outputs for generated data)
# 
# The function zips these together and for each pair (dr, dg):
# - Computes losses using torch.mean()
# - Calls .item() on tensors
# - Performs comparisons (>=, <) on tensors
# - Calls .mean() and .std() on tensors
# 
# We need to provide lists of small tensors with values in [0, 1] range (as they represent discriminator outputs)

disc_real_outputs = [
    torch.rand(2, 4),  # Batch of 2, 4 features
    torch.rand(3, 4),  # Different batch size for distinction
]

disc_generated_outputs = [
    torch.rand(2, 4),  # Batch of 2, 4 features
    torch.rand(3, 4),  # Different batch size for distinction
]

ARGS = {
    "disc_real_outputs": disc_real_outputs,
    "disc_generated_outputs": disc_generated_outputs,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
duration_loss Ran
ran on a synthesized input
jaywalnut310/glow-tts/commons.py
code served (permissive licence) · get_code("2b6c52ad9b61c287")
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 0, dtype family float, shape () 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)

# logw: predicted log duration (tensor)
# logw_: target log duration (tensor)
# lengths: sequence lengths for normalization (tensor)

# Create small tensors with distinct sizes for clarity
batch_size = 2
max_length = 4

# logw: predicted log durations, shape (batch_size, max_length)
logw = torch.randn(batch_size, max_length)

# logw_: target log durations, same shape as logw
logw_ = torch.randn(batch_size, max_length)

# lengths: actual lengths of sequences for each item in batch, shape (batch_size,)
lengths = torch.tensor([3, 4], dtype=torch.float32)

ARGS = {
    "logw": logw,
    "logw_": logw_,
    "lengths": lengths,
}
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 0, dtype family float, shape () — shape () 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
dynamic_range_compression Ran
ran; our contract draft was wrong, not the code
NVIDIA/tacotron2/audio_processing.py
code served (permissive licence) · get_code("83e2c862f7374ac7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 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

torch.manual_seed(0)

# Create a small tensor with positive values for dynamic range compression
# This simulates magnitude spectrogram or similar audio processing data
x = torch.rand(2, 4) * 10  # Random values between 0 and 10

# C is compression factor (default 1)
C = 1

# clip_val is minimum clipping value (default 1e-05)
clip_val = 1e-05

ARGS = {
    'x': x,
    'C': C,
    'clip_val': clip_val
}
Setup block drafted by
a language model, Claude Sonnet 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
dynamic_range_compression_torch Ran
ran; our contract draft was wrong, not the code
jaywalnut310/vits/mel_processing.py
code served (permissive licence) · get_code("262807b9eb9706a5")
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 torch.nn as nn

torch.manual_seed(0)

# Create a small positive tensor for input
# The function applies log and clamp operations, so we need positive values
x = torch.rand(2, 4) + 0.1  # Small batch with positive values

# Define compression factor
C = 1

# Define clipping value
clip_val = 1e-05

ARGS = {
    "x": x,
    "C": C,
    "clip_val": clip_val,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
dynamic_range_decompression_torch Ran
ran on a synthesized input
jaywalnut310/vits/mel_processing.py
code served (permissive licence) · get_code("78c12e563d5af53d")
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 torch.nn as nn

torch.manual_seed(0)

# Create a small tensor input
x = torch.randn(2, 4)

# Create compression factor
C = 1

# Map all parameters to values
ARGS = {
    "x": x,
    "C": C,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
expand_abbreviations Ran
ran; our contract draft was wrong, not the code
jaywalnut310/glow-tts/text/cleaners.py
code served (permissive licence) · get_code("cea1f83e9db28ed8")
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 str. 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 re

def expand_abbreviations(text):
    _abbreviations = [(re.compile('\\b%s\\.' % x[0], re.IGNORECASE), x[1]) for x in [('mrs', 'misess'), ('mr', 'mister'), ('dr', 'doctor'), ('st', 'saint'), ('co', 'company'), ('jr', 'junior'), ('maj', 'major'), ('gen', 'general'), ('drs', 'doctors'), ('rev', 'reverend'), ('lt', 'lieutenant'), ('hon', 'honorable'), ('sgt', 'sergeant'), ('capt', 'captain'), ('esq', 'esquire'), ('ltd', 'limited'), ('col', 'colonel'), ('ft', 'fort')]]
    for regex, replacement in _abbreviations:
        text = re.sub(regex, replacement, text)
    return text

ARGS = {
    'text': 'Dr. Smith and Mrs. Johnson went to the fort. Mr. Brown is a colonel.'
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
feature_loss Ran
ran; our contract draft was wrong, not the code
jaywalnut310/vits/losses.py
pointer only (licence: MIT); the stored copy get_code serves, from wxzyd123/pivotal_objective_perturbation, is pointer only (licence: NONE) · get_code("24e8b4731dc3e070")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from wxzyd123/pivotal_objective_perturbation, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

feature_loss Ran
ran, honoured the contract we drafted
maum-ai/phaseaug/models.py
pointer only (licence: BSD-3-Clause); the stored copy get_code serves, from zjzser/wmcodec, is pointer only (licence: NONE) · get_code("e453b51f0ed5fb28")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (BSD-3-Clause), but get_code serves the stored copy, first harvested from zjzser/wmcodec, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

fused_add_tanh_sigmoid_multiply Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("b38f9c28c5117398")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

generate_path Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
jmp84/vits/models.py
code served (permissive licence) · get_code("6981a5db6f046922")
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 4, dtype family float, shape (2, 1, 5, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# duration: [b, 1, t_x] - batch size 2, 1 channel, time steps 4
duration = torch.tensor([[[1, 2, 1, 3]]], dtype=torch.long).expand(2, 1, 4)

# mask: [b, 1, t_y, t_x] - batch size 2, 1 channel, time y 5, time x 4
mask = torch.ones(2, 1, 5, 4, dtype=torch.float32)

ARGS = {
    "duration": duration,
    "mask": mask,
}
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 4, dtype family float, shape (2, 1, 5, 4) — shape (2, 1, 5, 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
generator_loss Ran
ran; our contract draft was wrong, not the code
jaywalnut310/vits/losses.py
pointer only (licence: MIT); the stored copy get_code serves, from wxzyd123/pivotal_objective_perturbation, is pointer only (licence: NONE) · get_code("6191fd9efbdd55d4")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from wxzyd123/pivotal_objective_perturbation, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

generator_loss Ran
ran; our contract draft was wrong, not the code
maum-ai/phaseaug/models.py
pointer only (licence: BSD-3-Clause); the stored copy get_code serves, from zjzser/wmcodec, is pointer only (licence: NONE) · get_code("1a9d74439d969cfd")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (BSD-3-Clause), but get_code serves the stored copy, first harvested from zjzser/wmcodec, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

get_padding Ran
ran, honoured the contract we drafted
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("a26f85d7c72ef39a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

griffin_lim Ran
ran; our contract draft was wrong, not the code
NVIDIA/tacotron2/audio_processing.py
code served (permissive licence) · get_code("9f9ec26d4cdfdf7d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Sonnet 4.5, prompt python_fixture_v1) and returned Tensor, ndim 2, dtype family float, shape (2, 11) 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)

class STFT:
    def __init__(self):
        pass
    
    def transform(self, signal):
        # Returns (magnitudes, angles)
        # signal shape: (batch, time)
        batch_size = signal.size(0)
        time_len = signal.size(1)
        # Return magnitudes and angles with shape (batch, freq, time_frames)
        freq_bins = 5
        time_frames = 7
        magnitudes = torch.abs(torch.randn(batch_size, freq_bins, time_frames))
        angles = torch.randn(batch_size, freq_bins, time_frames)
        return magnitudes, angles
    
    def inverse(self, magnitudes, angles):
        # magnitudes shape: (batch, freq, time_frames)
        # angles shape: (batch, freq, time_frames)
        # Returns signal with shape (batch, 1, time)
        batch_size = magnitudes.size(0)
        time_len = 11
        signal = torch.randn(batch_size, 1, time_len)
        return signal

stft_fn = STFT()

# Create magnitudes tensor with shape (batch=2, freq=5, time_frames=7)
magnitudes = torch.abs(torch.randn(2, 5, 7))

ARGS = {
    'magnitudes': magnitudes,
    'stft_fn': stft_fn,
    'n_iters': 3
}
Setup block drafted by
a language model, Claude Sonnet 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 11) — shape (2, 11) 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
intersperse Ran
ran; our contract draft was wrong, not the code
jaywalnut310/glow-tts/commons.py
pointer only (licence: MIT); the stored copy get_code serves, from wxzyd123/pivotal_objective_perturbation, is pointer only (licence: NONE) · get_code("c01a3efb274ff778")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from wxzyd123/pivotal_objective_perturbation, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

latest_checkpoint_path Ran
ran; our contract draft was wrong, not the code
jaywalnut310/glow-tts/utils.py
pointer only (licence: MIT); the stored copy get_code serves, from hayeong0/Diff-HierVC, is pointer only (licence: NONE) · get_code("321604dda57bb02d")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from hayeong0/Diff-HierVC, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_checkpoint Ran
ran; our contract draft was wrong, not the code
jaywalnut310/vits/utils.py
pointer only (licence: MIT); the stored copy get_code serves, from hayeong0/Diff-HierVC, is pointer only (licence: NONE) · get_code("c647283e53cacacf")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from hayeong0/Diff-HierVC, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

load_checkpoint Ran
ran on a synthesized input
jaywalnut310/glow-tts/utils.py
code served (permissive licence) · get_code("a4324b03a174abb9")
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 tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import tempfile
import os

torch.manual_seed(0)

# Create a minimal model
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.linear(x)

# Create a minimal optimizer
model = SimpleModel()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# Create a checkpoint dictionary
checkpoint_dict = {
    'model': model.state_dict(),
    'optimizer': optimizer.state_dict(),
    'iteration': 42,
    'learning_rate': 0.001
}

# Write checkpoint to a temporary file
with tempfile.NamedTemporaryFile(delete=False, suffix='.pt') as f:
    checkpoint_path = f.name
    torch.save(checkpoint_dict, checkpoint_path)

# Create fresh model and optimizer for loading
loaded_model = SimpleModel()
loaded_optimizer = torch.optim.SGD(loaded_model.parameters(), lr=0.01)

ARGS = {
    'checkpoint_path': checkpoint_path,
    'model': loaded_model,
    'optimizer': loaded_optimizer
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
lowercase Ran
ran on a synthesized input
jaywalnut310/glow-tts/text/cleaners.py
code served (permissive licence) · get_code("296274b940cb0b32")
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 str. 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

torch.manual_seed(0)

ARGS = {
    "text": "Hello World"
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str 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
mle_loss Ran
ran on a synthesized input
jaywalnut310/glow-tts/commons.py
code served (permissive licence) · get_code("77759e4586956310")
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 0, dtype family float, shape () 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)

# Construct arguments for mle_loss function
# z: latent representation tensor
z = torch.randn(2, 4)

# m: mean tensor
m = torch.randn(2, 4)

# logs: log standard deviation tensor
logs = torch.randn(2, 4)

# logdet: log determinant tensor (scalar or broadcastable)
logdet = torch.randn(1)

# mask: binary mask tensor for weighting
mask = torch.ones(2, 4)

ARGS = {
    "z": z,
    "m": m,
    "logs": logs,
    "logdet": logdet,
    "mask": mask,
}
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 0, dtype family float, shape () — shape () 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
rand_slice_segments Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("0b891bcd5e4b4be1")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

read_table Ran
ran on a synthesized input
wenet-e2e/wetts/wetts/frontend/utils.py
code served (permissive licence) · get_code("eb2a1b4e5d25755d")
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 tempfile
import os

# Create a temporary file with some test data
temp_file = tempfile.NamedTemporaryFile(mode='w', delete=False, encoding='utf8', suffix='.txt')
temp_file.write("apple\n")
temp_file.write("banana\n")
temp_file.write("cherry\n")
temp_file.close()

dict_file = temp_file.name

ARGS = {
    'dict_file': dict_file
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
sequence_mask Ran
ran; our contract draft was wrong, not the code
this paper's copy was not recorded; identical code first harvested from guozixunnicolas/fundamentalmusicembedding
pointer only; the stored copy get_code serves, from guozixunnicolas/fundamentalmusicembedding, is pointer only (licence: NONE) · get_code("88bf809d1bc9db4c")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

slice_segments Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("5e342f73b3b911ec")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

spectral_normalize_torch Ran
ran; our contract draft was wrong, not the code
jaywalnut310/vits/mel_processing.py
code served (permissive licence) · get_code("26b87488d429896a")
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

torch.manual_seed(0)

# Create a small magnitude tensor (batch_size=2, frequency_bins=4)
magnitudes = torch.rand(2, 4) + 0.1  # Add 0.1 to ensure values are well above 0

# Define arguments for spectral_normalize_torch
ARGS = {
    "magnitudes": magnitudes,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
spectrogram_torch Ran
ran; our contract draft was wrong, not the code
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("2a01b8026e5c2bc7")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

spectrogram_torch_data Ran
ran; our contract draft was wrong, not the code
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("08beff5564cff157")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

unconstrained_rational_quadratic_spline Ran
ran; our contract draft was wrong, not the code
jmp84/vits/models.py
code served (permissive licence) · get_code("9e31572da16d9de4")
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 tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F
import numpy as np

torch.manual_seed(0)

# Create small tensors with distinct dimensions
batch_size = 2
num_bins = 4

# inputs: shape (batch_size,) - values within [-tail_bound, tail_bound]
inputs = torch.tensor([0.5, -0.3], dtype=torch.float32)

# unnormalized_widths: shape (batch_size, num_bins)
unnormalized_widths = torch.randn(batch_size, num_bins, dtype=torch.float32)

# unnormalized_heights: shape (batch_size, num_bins)
unnormalized_heights = torch.randn(batch_size, num_bins, dtype=torch.float32)

# unnormalized_derivatives: shape (batch_size, num_bins)
unnormalized_derivatives = torch.randn(batch_size, num_bins, dtype=torch.float32)

ARGS = {
    'inputs': inputs,
    'unnormalized_widths': unnormalized_widths,
    'unnormalized_heights': unnormalized_heights,
    'unnormalized_derivatives': unnormalized_derivatives,
    'inverse': False,
    'tails': 'linear',
    'tail_bound': 1.0,
    'min_bin_width': 0.001,
    'min_bin_height': 0.001,
    'min_derivative': 0.001,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
unconstrained_rational_quadratic_spline Ran
ran; our contract draft was wrong, not the code
jaywalnut310/vits/transforms.py
pointer only (licence: MIT); the stored copy get_code serves, from hayeong0/Diff-HierVC, is pointer only (licence: NONE) · get_code("70a7614b3b3eb41f")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (MIT), but get_code serves the stored copy, first harvested from hayeong0/Diff-HierVC, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ConvFlow Not yet run
unverified (harvested, no recorded run)
jmp84/vits/models.py
code served (permissive licence) · get_code("6121d5117e03763b")
How it ran

no invocation recorded.

Encoder Not yet run
unverified (harvested, no recorded run)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("62c7b592b2d2297b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

Encoder Not yet run
unverified (harvested, no recorded run)
olawod/freevc/models.py
code served (permissive licence) · get_code("862e2838890719eb")
How it ran

no invocation recorded.

Generator Not yet run
unverified (harvested, no recorded run)
olawod/freevc/models.py
code served (permissive licence) · get_code("b9e59ecadc84c228")
How it ran

no invocation recorded.

Generator Not yet run
unverified (harvested, no recorded run)
jmp84/vits/models.py
code served (permissive licence) · get_code("fa239ec0b64f95b1")
How it ran

no invocation recorded.

PosteriorEncoder Not yet run
unverified (harvested, no recorded run)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("c148debeb5b49924")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

ResidualCouplingBlock Not yet run
unverified (harvested, no recorded run)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("20b53a6e6135c48b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

ResidualCouplingBlock Not yet run
unverified (harvested, no recorded run)
olawod/freevc/models.py
code served (permissive licence) · get_code("7f154bf0fb8dcbbb")
How it ran

no invocation recorded.

ResidualCouplingLayer Not yet run
unverified (harvested, no recorded run)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("60a5c0ef9ff2d916")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

ResidualCouplingLayer Not yet run
unverified (harvested, no recorded run)
olawod/freevc/models.py
code served (permissive licence) · get_code("1541e569125c52bd")
How it ran

no invocation recorded.

StochasticDurationPredictor Not yet run
unverified (harvested, no recorded run)
jmp84/vits/models.py
code served (permissive licence) · get_code("76a16536fc995a46")
How it ran

no invocation recorded.

SynthesizerTrn Not yet run
unverified (harvested, no recorded run)
isletennos/mmvc_trainer/models.py
pointer only (licence: NONE) · get_code("c21db10c88a81887")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isletennos/mmvc_trainer when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

SynthesizerTrn Not yet run
unverified (harvested, no recorded run)
olawod/freevc/models.py
code served (permissive licence) · get_code("f0ac43353f543134")
How it ran

no invocation recorded.

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("2106.06103").

Also present in other papers' code

Of 77 samples lifted from this paper's linked repositories, 77 carry a function identity and 0 do not. Of the 71 distinct functions with an identity, 35 are also present in other papers whose code we hold (22 with at least one paper dated earlier, 4 the same month, 29 later) and 36 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
get_padding
brick of this paper's assembly: helper
53 other papers
5 dated earlier, 2 the same month, 45 later, 1 undated · 4 only as an assembly brick
1910.10838 (2019-10)
Zero-Shot Multi-Speaker Text-To-Speech with State-of-the-art Neural Speaker Embeddings
2006.04558 (2020-06)
FastSpeech 2: Fast and High-Quality End-to-End Text to Speech
2006.06873 (2020-06)
FastPitch: Parallel Text-to-speech with Pitch Prediction
and 50 more not named here
feature_loss 15 other papers
1 dated earlier, 1 the same month, 13 later
2006.04558 (2020-06)
FastSpeech 2: Fast and High-Quality End-to-End Text to Speech
2106.07889 (2021-06)
UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation
2109.13821 (2021-09)
Diffusion-Based Voice Conversion with Fast Maximum Likelihood Sampling Scheme
and 12 more not named here
griffin_lim 14 other papers
11 dated earlier, 3 later
1803.09017 (2018-03)
Style Tokens: Unsupervised Style Modeling, Control and Transfer in End-to-End Speech Synthesis
1811.02122 (2018-11)
Robust and fine-grained prosody control of end-to-end speech synthesis
1812.04342 (2018-12)
Learning latent representations for style control and transfer in end-to-end speech synthesis
and 11 more not named here
dynamic_range_compression 13 other papers
12 dated earlier, 1 later
1803.09017 (2018-03)
Style Tokens: Unsupervised Style Modeling, Control and Transfer in End-to-End Speech Synthesis
1811.02122 (2018-11)
Robust and fine-grained prosody control of end-to-end speech synthesis
1812.04342 (2018-12)
Learning latent representations for style control and transfer in end-to-end speech synthesis
and 10 more not named here
generator_loss 13 other papers
1 dated earlier, 1 the same month, 11 later
2006.04558 (2020-06)
FastSpeech 2: Fast and High-Quality End-to-End Text to Speech
2106.07889 (2021-06)
UnivNet: A Neural Vocoder with Multi-Resolution Spectrogram Discriminators for High-Fidelity Waveform Generation
2109.13821 (2021-09)
Diffusion-Based Voice Conversion with Fast Maximum Likelihood Sampling Scheme
and 10 more not named here
intersperse 13 other papers
2 dated earlier, 11 later
2005.11129 (2020-05)
Glow-TTS: A Generative Flow for Text-to-Speech via Monotonic Alignment Search
2105.06337 (2021-05)
Grad-TTS: A Diffusion Probabilistic Model for Text-to-Speech
2204.09079 (2022-04)
Music Source Separation with Generative Flow
and 10 more not named here
convert_pad_shape
brick of this paper's assembly: helper
12 other papers
12 later
2109.13821 (2021-09)
Diffusion-Based Voice Conversion with Fast Maximum Likelihood Sampling Scheme
2109.15166 (2021-09)
PortaSpeech: Portable and High-Quality Generative Text-to-Speech
2204.11792 (2022-04)
SyntaSpeech: Syntax-Aware Generative Adversarial Text-to-Speech
and 9 more not named here
searchsorted
brick of this paper's assembly: helper
9 other papers
1 dated earlier, 8 later · 1 only as an assembly brick
2007.09390 (2020-07)
Autoregressive flow-based causal discovery and inference
2206.04658 (2022-06)
BigVGAN: A Universal Neural Vocoder with Large-Scale Training
2210.06370 (2022-10)
Can we use Common Voice to train a Multi-Speaker TTS system?
and 6 more not named here
expand_abbreviations 8 other papers
4 dated earlier, 4 later
1703.10135 (2017-03)
Tacotron: Towards End-to-End Speech Synthesis
2005.01245 (2020-05)
Can Speaker Augmentation Improve Multi-Speaker End-to-End TTS?
2005.05957 (2020-05)
Flowtron: an Autoregressive Flow-based Generative Network for Text-to-Speech Synthesis
and 5 more not named here
dynamic_range_compression_torch 7 other papers
7 later
2110.02500 (2021-10)
MediumVC: Any-to-any voice conversion using synthetic specific-speaker speeches as intermedium features
2206.04658 (2022-06)
BigVGAN: A Universal Neural Vocoder with Large-Scale Training
2305.19709 (2023-05)
XPhoneBERT: A Pre-trained Multilingual Model for Phoneme Representations for Text-to-Speech
and 4 more not named here
piecewise_rational_quadratic_transform
brick of this paper's assembly: helper
7 other papers
7 later
2206.04658 (2022-06)
BigVGAN: A Universal Neural Vocoder with Large-Scale Training
2210.06370 (2022-10)
Can we use Common Voice to train a Multi-Speaker TTS system?
2305.19709 (2023-05)
XPhoneBERT: A Pre-trained Multilingual Model for Phoneme Representations for Text-to-Speech
and 4 more not named here
sequence_mask
brick of this paper's assembly: helper
7 other papers
1 dated earlier, 6 later
2006.04558 (2020-06)
FastSpeech 2: Fast and High-Quality End-to-End Text to Speech
2109.15166 (2021-09)
PortaSpeech: Portable and High-Quality Generative Text-to-Speech
2204.11792 (2022-04)
SyntaSpeech: Syntax-Aware Generative Adversarial Text-to-Speech
and 4 more not named here
unconstrained_rational_quadratic_spline
brick of this paper's assembly: helper
7 other papers
7 later
2206.04658 (2022-06)
BigVGAN: A Universal Neural Vocoder with Large-Scale Training
2210.06370 (2022-10)
Can we use Common Voice to train a Multi-Speaker TTS system?
2305.19709 (2023-05)
XPhoneBERT: A Pre-trained Multilingual Model for Phoneme Representations for Text-to-Speech
and 4 more not named here
fused_add_tanh_sigmoid_multiply
brick of this paper's assembly: helper
6 other papers
3 dated earlier, 1 the same month, 2 later · 1 only as an assembly brick
1803.09017 (2018-03)
Style Tokens: Unsupervised Style Modeling, Control and Transfer in End-to-End Speech Synthesis
1811.00002 (2018-11)
WaveGlow: A Flow-based Generative Network for Speech Synthesis
2006.04598 (2020-06)
WaveNODE: A Continuous Normalizing Flow for Speech Synthesis
and 3 more not named here
init_weights
brick of this paper's assembly: helper
6 other papers
1 dated earlier, 5 later · 6 only as an assembly brick
2010.05646 (2020-10)
HiFi-GAN: Generative Adversarial Networks for Efficient and High Fidelity Speech Synthesis
2110.14513 (2021-10)
Neural Analysis and Synthesis: Reconstructing Speech from Self-Supervised Representations
2202.07359 (2022-02)
textless-lib: a Library for Textless Spoken Language Processing
and 3 more not named here
lowercase 6 other papers
4 dated earlier, 2 later
1703.10135 (2017-03)
Tacotron: Towards End-to-End Speech Synthesis
2005.01245 (2020-05)
Can Speaker Augmentation Improve Multi-Speaker End-to-End TTS?
2005.11129 (2020-05)
Glow-TTS: A Generative Flow for Text-to-Speech via Monotonic Alignment Search
and 3 more not named here
spectral_normalize_torch 6 other papers
6 later
2110.02500 (2021-10)
MediumVC: Any-to-any voice conversion using synthetic specific-speaker speeches as intermedium features
2206.04658 (2022-06)
BigVGAN: A Universal Neural Vocoder with Large-Scale Training
2305.19709 (2023-05)
XPhoneBERT: A Pre-trained Multilingual Model for Phoneme Representations for Text-to-Speech
and 3 more not named here
apply_gradient_allreduce 5 other papers
4 dated earlier, 1 later
1811.02122 (2018-11)
Robust and fine-grained prosody control of end-to-end speech synthesis
1812.04342 (2018-12)
Learning latent representations for style control and transfer in end-to-end speech synthesis
1907.04448 (2019-07)
Learning to Speak Fluently in a Foreign Language: Multilingual Speech Synthesis and Cross-Language Voice Cloning
and 2 more not named here
discriminator_loss 5 other papers
5 later
2206.04658 (2022-06)
BigVGAN: A Universal Neural Vocoder with Large-Scale Training
2305.19709 (2023-05)
XPhoneBERT: A Pre-trained Multilingual Model for Phoneme Representations for Text-to-Speech
2310.01889 (2023-10)
Ring Attention with Blockwise Transformers for Near-Infinite Context
and 2 more not named here
feature_loss 5 other papers
5 later
2206.04658 (2022-06)
BigVGAN: A Universal Neural Vocoder with Large-Scale Training
2305.19709 (2023-05)
XPhoneBERT: A Pre-trained Multilingual Model for Phoneme Representations for Text-to-Speech
2310.01889 (2023-10)
Ring Attention with Blockwise Transformers for Near-Infinite Context
and 2 more not named here

Shown: the 20 functions present in the most other papers. 15 more shared functions are not listed here.

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

Several recent end-to-end text-to-speech (TTS) models enabling single-stage training and parallel sampling have been proposed, but their sample quality does not match that of two-stage TTS systems. In this work, we present a parallel endto-end TTS method that generates more natural sounding audio than current two-stage models. Our method adopts variational inference augmented with normalizing flows and an adversarial training process, which improves the expressive power of generative modeling. We also propose a stochastic duration predictor to synthesize speech with diverse rhythms from input text. With the uncertainty modeling over latent variables and the stochastic duration predictor, our method expresses the natural one-to-many relationship in which a text input can be spoken in multiple ways with different pitches and rhythms. A subjective human evaluation (mean opinion score, or MOS) on the LJ Speech, a single speaker dataset, shows that our method outperforms the best publicly available TTS systems and achieves a MOS comparable to ground truth. 1 Although there is a text preprocessing step in TTS systems, We herein use preprocessed text interchangeably with the word "text".

For agents

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

get_harvested_code_for_paper("2106.06103")
get_code_for_paper("2106.06103")
have("2106.06103")

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

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

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

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

Connect an agent — have() is free.