SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2003.01941 · 2020

Gaussianization Flows

arXiv · PDF · Open in the Atlas

Code that ran

16 of 21 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 12 have no contract verdict; 4 failures of our instrument; 5 no recorded run), measured 2026-11-21; 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/2003.01941.json · badge: /api/ran/2003.01941.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
IPL-UV/rbig_jax canonical (classifier label)
classifier basis: census
6 ran · 3 no recorded run
chenlin9/Gaussianization_Flows canonical (classifier label)
classifier basis: classifier_2025
1 ran · 0 no recorded run
IPL-UV/gaussflow community (classifier label)
classifier basis not recorded on the link
9 ran · 2 no recorded run
FunctionStatusWhere it lives
add_wandb_args Ran
ran on a synthesized input
IPL-UV/gaussflow/src/experiments/utils.py
code served (permissive licence) · get_code("5d04f997a7a2e253")
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 ArgumentParser. 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 argparse import ArgumentParser

torch.manual_seed(0)

# The function add_wandb_args takes a parent_parser (ArgumentParser)
# and returns a new ArgumentParser with wandb-specific arguments added.
# It doesn't actually use the parser in any complex way - just passes it
# as a parent to a new ArgumentParser.

parent_parser = ArgumentParser()

ARGS = {
    'parent_parser': parent_parser
}
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 ArgumentParser — a ArgumentParser output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a ArgumentParser 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
conv_exp Ran
ran; our contract draft was wrong, not the code
IPL-UV/gaussflow/src/models/linear.py
code served (permissive licence) · get_code("93b57317942866eb")
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, 4, 8, 8) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn.functional as F

torch.manual_seed(0)

# Create a small input tensor: (batch=2, channels=4, height=8, width=8)
input_tensor = torch.randn(2, 4, 8, 8)

# Create a kernel tensor: (out_channels=4, in_channels=4, kernel_h=3, kernel_w=3)
# The function expects kernel.size(0) == kernel.size(1) == C
# So kernel shape is (C, C, kh, kw)
kernel_tensor = torch.randn(4, 4, 3, 3)

ARGS = {
    'input': input_tensor,
    'kernel': kernel_tensor,
    'terms': 10,
    'dynamic_truncation': 0,
    'verbose': False
}
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, 4, 8, 8) — shape (2, 4, 8, 8) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
flow_loss Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
chenlin9/Gaussianization_Flows/tabular_experiment.py
pointer only (licence: NONE) · get_code("d29ea21629f4ac1b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, chenlin9/Gaussianization_Flows 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_2d_grid Ran
ran on a synthesized input
IPL-UV/gaussflow/src/viz/bivariate.py
code served (permissive licence) · get_code("e8bea811f4c19c70")
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 ndarray, ndim 2, dtype family float, shape (10000, 2) 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 numpy as np

# Create sample 2D data with 5 points in 2D space
data = np.array([
    [0.0, 0.0],
    [1.0, 1.0],
    [0.5, 0.5],
    [1.5, 0.2],
    [0.2, 1.3]
], dtype=np.float32)

ARGS = {
    "data": data,
    "n_grid": 100,
    "buffer": 0.01
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (10000, 2) — shape (10000, 2) 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
get_quantiles Ran
ran on a synthesized input
IPL-UV/rbig_jax/rbig_jax/quantiles.py
code served (permissive licence) · get_code("c7f37f093738dc31")
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 jax.numpy as np

# Create a small test array
x = np.array([[1.0, 2.0, 3.0, 4.0],
              [5.0, 6.0, 7.0, 8.0]])

ARGS = {
    "x": x,
    "n_quantiles": 1000
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — 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
info_red_cond Ran
ran on a synthesized input
IPL-UV/rbig_jax/rbig_jax/stopping.py
code served (permissive licence) · get_code("dfd3476c2058eb71")
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 bool, 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 jax.numpy as np

def setup_args():
    # Analyze the function to understand what 'state' should contain:
    # state is unpacked as: i_layers, losses, tol_layers, max_layers
    # - i_layers: integer, compared with max_layers and tol_layers
    # - losses: list/array, indexed with [-tol_layers:] slice, elements summed with np.abs
    # - tol_layers: integer, used for slicing and comparison
    # - max_layers: integer, compared with i_layers
    
    i_layers = 5
    losses = [0.1, 0.2, 0.15, 0.05, 0.0, 0.02]  # list of floats
    tol_layers = 3
    max_layers = 10
    
    state = (i_layers, losses, tol_layers, max_layers)
    
    return state

ARGS = {
    'state': setup_args()
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, 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
marginal_transform Ran
ran on a synthesized input
IPL-UV/rbig_jax/rbig_jax/utils.py
code served (permissive licence) · get_code("5b1d0013e3b6ee41")
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 function. 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 jax
import jax.numpy as jnp

def simple_function(x):
    """A simple function that can be vmapped"""
    return x * 2 + 1

ARGS = {
    "f": simple_function
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type function — a function output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a function 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
matrix_exp Ran
ran; our contract draft was wrong, not the code
IPL-UV/gaussflow/src/models/linear.py
code served (permissive licence) · get_code("47b5ae77e59c4063")
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 (4, 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 square matrix for matrix exponential computation
# The function requires a square matrix (M.size(0) == M.size(1))
M = torch.randn(4, 4)

# Number of terms in the Taylor series expansion
terms = 10

ARGS = {
    "M": M,
    "terms": terms
}
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 (4, 4) — shape (4, 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
matrix_log Ran
ran; our contract draft was wrong, not the code
IPL-UV/gaussflow/src/models/linear.py
code served (permissive licence) · get_code("4e907657e24742b5")
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 (4, 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 square matrix for matrix_log
# The function expects B to be square (B.size(0) == B.size(1))
# and computes the matrix logarithm using a series expansion
B = torch.randn(4, 4)

# The terms parameter controls how many terms in the series expansion
terms = 10

ARGS = {
    "B": B,
    "terms": terms
}
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 (4, 4) — shape (4, 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
negative_log_likelihood_mse Ran
ran on a synthesized input
IPL-UV/gaussflow/src/losses/nll.py
code served (permissive licence) · get_code("0d1d4f0a005a7547")
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 torch.nn as nn

torch.manual_seed(0)

class SimpleDistribution(nn.Module):
    """A minimal model with a log_prob method."""
    def __init__(self, dim):
        super().__init__()
        self.dim = dim
        self.mean = nn.Parameter(torch.zeros(dim))
        self.log_std = nn.Parameter(torch.zeros(dim))
    
    def log_prob(self, x):
        """
        Returns log probability for input x.
        x shape: (batch_size, dim)
        Returns: (batch_size,)
        """
        std = torch.exp(self.log_std)
        var = std ** 2
        log_2pi = torch.tensor(2.0 * 3.14159265359).log()
        log_prob = -0.5 * (log_2pi + torch.log(var) + (x - self.mean) ** 2 / var)
        return log_prob.sum(dim=-1)

model = SimpleDistribution(dim=4)
x = torch.randn(2, 4)

ARGS = {
    "model": model,
    "x": x,
}
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
negative_log_likelihood_nats Ran
ran on a synthesized input
IPL-UV/gaussflow/src/losses/nll.py
code served (permissive licence) · get_code("0ce25394f9a9d587")
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 torch.nn as nn

torch.manual_seed(0)

class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(4, 1)
    
    def log_prob(self, x):
        # Return log probability as a tensor with same batch size as x
        # x shape: (batch_size, 4)
        # output shape: (batch_size,)
        logits = self.linear(x).squeeze(-1)
        # Simple log probability: use log_softmax-like behavior
        return logits - torch.logsumexp(logits, dim=0, keepdim=True)

model = SimpleModel()
x = torch.randn(2, 4)

ARGS = {
    "model": model,
    "x": x,
}
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
nll_2_bpd Ran
ran on a synthesized input
IPL-UV/rbig_jax/rbig_jax/losses.py
code served (permissive licence) · get_code("296a63ad389bce82")
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 ArrayImpl, 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 jax.numpy as jnp
import numpy as np

# Create a small NLL loss value
nll_loss = jnp.array(2.5)

# Create a small image shape tuple (e.g., 4x3x3 for a 4x3x3 image)
img_shape = (4, 3, 3)

ARGS = {
    "nll_loss": nll_loss,
    "img_shape": img_shape,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
chex, jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, 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
nll_loss Ran
ran on a synthesized input
IPL-UV/rbig_jax/rbig_jax/stopping.py
code served (permissive licence) · get_code("36a600d9e04a706d")
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 ArrayImpl, 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 jax
import jax.numpy as jnp
import numpy as np

# Set seed for reproducibility
np.random.seed(0)

# Create small example tensors
batch_size = 2
dim = 4

# X: shape (batch_size, dim) - input data
X = jnp.array(np.random.randn(batch_size, dim), dtype=jnp.float32)

# X_log_det: shape (batch_size, 1) - log determinant values
X_log_det = jnp.array(np.random.randn(batch_size, 1), dtype=jnp.float32)

ARGS = {
    "X": X,
    "X_log_det": X_log_det,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, 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
plot_2d_joint_probs Ran
ran on a synthesized input
IPL-UV/gaussflow/src/viz/bivariate.py
code served (permissive licence) · get_code("024690e22033fced")
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 numpy as np
import matplotlib.pyplot as plt

torch.manual_seed(0)

# Create sample 2D data points
data = np.random.randn(5, 2).astype(np.float32)

# Create corresponding probability values
probs = np.random.rand(5).astype(np.float32)

# Create a minimal wandb_logger stand-in class
class MockWandBLogger:
    def log(self, data_dict):
        pass

wandb_logger = MockWandBLogger()

# Define all arguments
ARGS = {
    'data': data,
    'probs': probs,
    'wandb_logger': wandb_logger,
    'log_name': '2d_joint',
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy, torch, wandb — 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
train_model Ran
ran on a synthesized input
IPL-UV/rbig_jax/rbig_jax/training_old.py
code served (permissive licence) · get_code("20bd2735a605c5b4")
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 jax
import jax.numpy as jnp
import numpy as np
from typing import Callable, Tuple

# Define a minimal optimizer state and functions
class DummyOptState:
    def __init__(self, params):
        self.params = params

def create_opt_params():
    """Create a minimal opt_params tuple (init, opt_state, get_params)"""
    def init_fn(params):
        return DummyOptState(params)
    
    def get_params_fn(opt_state):
        return opt_state.params
    
    initial_params = jnp.array([1.0, 2.0, 3.0, 4.0])
    opt_state = init_fn(initial_params)
    
    return (init_fn, opt_state, get_params_fn)

def create_train_op():
    """Create a minimal train_op callable that returns (loss, new_opt_state)"""
    def train_op(step, opt_state, batch):
        # Simple dummy loss computation
        loss = jnp.mean(batch) + jnp.array(step) * 0.001
        # Return the same opt_state (no actual update)
        return loss, opt_state
    
    return train_op

def create_data_loaders():
    """Create minimal train and valid data loaders"""
    # Each loader is a list of batches (small arrays)
    train_dl = [
        np.random.randn(2, 4).astype(np.float32),
        np.random.randn(2, 4).astype(np.float32),
    ]
    valid_dl = [
        np.random.randn(2, 4).astype(np.float32),
    ]
    return train_dl, valid_dl

# Create arguments
train_op = create_train_op()
opt_params = create_opt_params()
train_dl, valid_dl = create_data_loaders()

ARGS = {
    'train_op': train_op,
    'opt_params': opt_params,
    'train_dl': train_dl,
    'valid_dl': valid_dl,
    'epochs': 2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy, tqdm — 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
update_args_yaml Ran
ran on a synthesized input
IPL-UV/gaussflow/src/experiments/utils.py
code served (permissive licence) · get_code("02b9eaf38b243876")
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 yaml
import tempfile
import os

# Create a temporary YAML file with some test configuration
yaml_content = """
learning_rate: 0.001
batch_size: 32
epochs: 10
model_name: "test_model"
"""

# Write YAML to a temporary file
with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
    f.write(yaml_content)
    yaml_file_path = f.name

try:
    # Create a simple args object (using a dict converted to namespace-like object)
    class Args:
        def __init__(self):
            self.learning_rate = 0.01
            self.batch_size = 16
            self.other_param = "original_value"
    
    args = Args()
    
    ARGS = {
        "args": args,
        "yaml_file": yaml_file_path
    }
finally:
    # Clean up will happen after function execution
    pass
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
yaml — 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
init_train_op Not yet run
unverified (harvested, no recorded run)
IPL-UV/rbig_jax/rbig_jax/training_old.py
code served (permissive licence) · get_code("f6023901bf40e193")
How it ran

no invocation recorded.

negative_log_likelihood_bpd Not yet run
unverified (harvested, no recorded run)
IPL-UV/gaussflow/src/losses/nll.py
code served (permissive licence) · get_code("6694e2ccbc71cc1e")
How it ran

no invocation recorded.

plot_2d_joint Not yet run
unverified (harvested, no recorded run)
IPL-UV/gaussflow/src/viz/bivariate.py
code served (permissive licence) · get_code("674424cf743e0c7a")
How it ran

no invocation recorded.

reverse_dataclass_params Not yet run
unverified (harvested, no recorded run)
IPL-UV/rbig_jax/rbig_jax/utils.py
code served (permissive licence) · get_code("9c80db9b624b5c3a")
How it ran

no invocation recorded.

safe_log Not yet run
unverified (harvested, no recorded run)
IPL-UV/rbig_jax/rbig_jax/utils.py
code served (permissive licence) · get_code("105717a22f1e0c02")
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, 3 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 3 later) and 18 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
conv_exp 1 other paper
1 later
2006.01910 (2020-06)
The Convolution Exponential and Generalized Sylvester Flows
matrix_exp 1 other paper
1 later
2006.01910 (2020-06)
The Convolution Exponential and Generalized Sylvester Flows
matrix_log 1 other paper
1 later
2006.01910 (2020-06)
The Convolution Exponential and Generalized Sylvester Flows

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-21.

Repositories linked to this paper

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

Abstract

Iterative Gaussianization is a fixed-point iteration procedure that can transform any continuous random vector into a Gaussian one. Based on iterative Gaussianization, we propose a new type of normalizing flow model that enables both efficient computation of likelihoods and efficient inversion for sample generation. We demonstrate that these models, named Gaussianization flows, are universal approximators for continuous probability distributions under some regularity conditions. Because of this guaranteed expressivity, they can capture multimodal target distributions without compromising the efficiency of sample generation. Experimentally, we show that Gaussianization flows achieve better or comparable performance on several tabular datasets compared to other efficiently invertible flow models such as Real NVP, Glow and FFJORD. In particular, Gaussianization flows are easier to initialize, demonstrate better robustness with respect to different transformations of the training data, and generalize better on small training sets.

For agents

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

get_harvested_code_for_paper("2003.01941")
get_code_for_paper("2003.01941")
have("2003.01941")

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

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

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

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

Connect an agent — have() is free.