SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2402.04823 · ICLR · 2024

How Realistic Is Your Synthetic Data? Constraining Deep Generative Models for Tabular Data

Thomas Lukasiewicz, Mihaela Stoian, Salijona Dyrmishi, Maxime Cordy, Eleonora Giunchiglia

arXiv · PDF · Open in the Atlas

Code that ran

10 of 10 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; 1 honoured the contract we drafted, 1 violated it and 0 have no contract verdict; 8 failures of our instrument; 0 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/2402.04823.json · badge: /api/ran/2402.04823.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
mihaela-stoian/constraineddgm canonical (classifier label)
classifier basis: census
10 ran · 0 no recorded run
FunctionStatusWhere it lives
all_div_gt_n Ran
ran, honoured the contract we drafted
mihaela-stoian/constraineddgm/utils.py
code served (permissive licence) · get_code("2c0be1f9a20d536d")
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 int, ndim 0, dtype family int, 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.

ARGS = {
    "n": 2,
    "m": 12
}
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 int, ndim 0, dtype family int, 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
apply_or Ran
ran, violated the contract we drafted
mihaela-stoian/constraineddgm/constraints/faults.py
code served (permissive licence) · get_code("ade9519558a21ef8")
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 (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 numpy as np

# The function apply_or takes operands and returns np.min(operands, axis=0)
# operands should be array-like that can be passed to np.min with axis=0
# This means it should be a sequence of arrays or a 2D+ array

# Create a small 2D numpy array (batch of 2, features of 4)
operand1 = np.array([[1.0, 2.0, 3.0, 4.0],
                     [5.0, 6.0, 7.0, 8.0]])

operand2 = np.array([[0.5, 1.5, 2.5, 3.5],
                     [4.5, 5.5, 6.5, 7.5]])

operand3 = np.array([[2.0, 3.0, 4.0, 5.0],
                     [6.0, 7.0, 8.0, 9.0]])

# Stack them to create operands - shape (3, 2, 4)
# When axis=0 is applied, it will find min across the first dimension
operands = np.array([operand1, operand2, operand3])

ARGS = {
    "operands": operands
}
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 (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
evaluate_numpy_botnet Ran
ran; our contract draft was wrong, not the code
mihaela-stoian/constraineddgm/constraints/botnet.py
code served (permissive licence) · get_code("b26964eb404e345b")
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 (2, 362) 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
import autograd.numpy as anp
import pickle
import os
import tempfile

# Create a temporary directory and pickle file for feat_dict
temp_dir = tempfile.mkdtemp()
data_dir = os.path.join(temp_dir, 'data', 'botnet')
os.makedirs(data_dir, exist_ok=True)

# Build a minimal feat_dict that satisfies the function's requirements
feat_dict = {}

# Add features for the first constraint (g1, g2)
for prefix in ['icmp_sum_s_', 'udp_sum_s_', 'tcp_sum_s_', 'bytes_in_sum_s_', 'bytes_out_sum_s_',
               'icmp_sum_d_', 'udp_sum_d_', 'tcp_sum_d_', 'bytes_in_sum_d_', 'bytes_out_sum_d_']:
    feat_dict[prefix + '0'] = len(feat_dict)

# Add packet size features
for e in ['s', 'd']:
    for i in range(2):
        feat_dict[f'bytes_out_sum_{e}_{i}'] = len(feat_dict)
        feat_dict[f'pkts_out_sum_{e}_{i}'] = len(feat_dict)

# Add min/max/sum features for all combinations
for e_1 in ['bytes_out', 'pkts_out', 'duration']:
    for port in ['1', '3', '8', '10', '21', '22', '25', '53', '80', '110', '123', '135', '138', '161', '443', '445', '993', 'OTHER']:
        for e_2 in ['d', 's']:
            feat_dict[f'{e_1}_max_{e_2}_{port}'] = len(feat_dict)
            feat_dict[f'{e_1}_sum_{e_2}_{port}'] = len(feat_dict)
            feat_dict[f'{e_1}_min_{e_2}_{port}'] = len(feat_dict)

# Save the feat_dict to pickle file
with open(os.path.join(data_dir, 'feat_dict.pkl'), 'wb') as handle:
    pickle.dump(feat_dict, handle)

# Create input data with appropriate number of features
num_features = len(feat_dict)
batch_size = 2
x = np.random.randn(batch_size, num_features)

# Update the data directory for the function to find it
original_cwd = os.getcwd()
os.chdir(temp_dir)

ARGS = {
    'x': x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
autograd, 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 (2, 362) — shape (2, 362) 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
evaluate_numpy_faults Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mihaela-stoian/constraineddgm/constraints/faults.py
code served (permissive licence) · get_code("f64fc6cd4c301677")
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 (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 numpy as np

# Construct a small numpy array with shape (batch_size, num_features)
# The function accesses columns 0, 1, 2, 3, 7, 8, 9
# So we need at least 10 columns (indices 0-9)
# Use batch size 2 and 10 features to satisfy all indexing
x = np.random.rand(2, 10)

ARGS = {
    'x': x
}
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 (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
evaluate_numpy_lcld Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mihaela-stoian/constraineddgm/constraints/lcld.py
code served (permissive licence) · get_code("28767778b828cb97")
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 (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 numpy as np
import autograd.numpy as anp

# Create a sample input array with shape (2, 28)
# The function indexes columns 0-27, so we need at least 28 columns
# Batch size is 2, dimensions are column indices 0-27

x = np.random.rand(2, 28) * 100

# Set specific values to ensure valid computations
# x[:, 0] = principal amount
x[:, 0] = np.array([10000, 20000])

# x[:, 1] = number of months (between 36 and 60)
x[:, 1] = np.array([48, 50])

# x[:, 2] = monthly interest rate (as percentage, e.g., 5 for 5%)
x[:, 2] = np.array([5, 6])

# x[:, 3] = calculated installment
x[:, 3] = np.array([250, 400])

# x[:, 7] = some denominator for ratio calculation
x[:, 7] = np.array([100, 200])

# x[:, 11] = numerator
x[:, 11] = np.array([500, 600])

# x[:, 12] = denominator (avoid zero to prevent division issues)
x[:, 12] = np.array([50, 60])

# x[:, 15] = another value for constraint
x[:, 15] = np.array([450, 580])

# x[:, 19] = numerator for ratio
x[:, 19] = np.array([300, 350])

# x[:, 22] = ratio check value
x[:, 22] = np.array([100, 100])

# x[:, 23] = another ratio check
x[:, 23] = np.array([10, 10])

# x[:, 24] = denominator for constraints
x[:, 24] = np.array([30, 35])

# x[:, 25] and x[:, 26] = values to compare
x[:, 25] = np.array([10, 10])
x[:, 26] = np.array([10, 10])

# x[:, 27] = ratio comparison value
x[:, 27] = np.array([6, 5.83])

ARGS = {
    "x": x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
autograd, 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 (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
evaluate_numpy_news Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mihaela-stoian/constraineddgm/constraints/news.py
code served (permissive licence) · get_code("23ea68c400dcc59e")
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 (2, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a numpy array with shape (batch_size, num_features)
# The function accesses indices up to 29, so we need at least 30 columns
# Using batch size of 2 as per requirements
x = np.random.randn(2, 30).astype(np.float32)

# Ensure the array has the required structure for the constraints
# Set some values to test the tolerance logic
x[0, 1] = 1.0   # for g1
x[0, 2] = 0.5
x[0, 5] = 2.0   # for g2
x[0, 3] = 1.0
x[0, 7] = 3.0   # for g3
x[0, 6] = 2.5
x[0, 27] = 4.0  # for g4
x[0, 28] = 3.5
x[0, 29] = 4.5  # for g5

x[1, 1] = 0.9
x[1, 2] = 0.89
x[1, 5] = 1.5
x[1, 3] = 1.4
x[1, 7] = 2.0
x[1, 6] = 1.9
x[1, 27] = 5.0
x[1, 28] = 4.9
x[1, 29] = 5.1

ARGS = {
    "x": x
}
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 (2, 5) — shape (2, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
evaluate_numpy_url Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mihaela-stoian/constraineddgm/constraints/url.py
code served (permissive licence) · get_code("53cf21ac0f5b4f27")
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 (2, 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 numpy as np

# Analyze the function to understand what x should be:
# - x is indexed with x[:, 0], x[:, 1], x[:, 3:18], x[:, 19], x[:, 20], x[:, 21], x[:, 22], x[:, 23], x[:, 37], x[:, 38]
# - Maximum column index used is 38, so we need at least 39 columns
# - The function operates on rows (batch dimension), so we need multiple rows
# - All operations are vectorized along axis 0 (rows)

# Create a small valid input array
# Shape: (batch_size, num_features) where num_features >= 39
batch_size = 2
num_features = 40

x = np.random.randn(batch_size, num_features).astype(np.float32)

# Ensure some reasonable values for the constraints to make sense
x[:, 0] = np.abs(x[:, 0]) + 1.0  # Make first column positive and non-zero
x[:, 1:] = np.abs(x[:, 1:]) + 0.5  # Make other columns positive

ARGS = {
    "x": x
}
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 (2, 8) — shape (2, 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
evaluate_numpy_wids Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
mihaela-stoian/constraineddgm/constraints/wids.py
code served (permissive licence) · get_code("55e2bd38ff6c408b")
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 (2, 31) 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 autograd.numpy as anp
import numpy as np

torch_seed = 0

# Analyze the function:
# - Takes parameter 'x'
# - Accesses x[:, i] for columns from 33 to 93 (with step 2)
# - Needs columns up to index 94, so x must have at least 95 columns
# - Stacks results using anp.column_stack()

# Create a small test array with batch size 2 and enough columns
batch_size = 2
num_columns = 95  # Need at least 95 columns to access indices up to 94

x = anp.arange(batch_size * num_columns).reshape(batch_size, num_columns).astype(anp.float32)

ARGS = {
    'x': x
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
autograd, 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 (2, 31) — shape (2, 31) 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
round_func_BPDA Ran
ran; our contract draft was wrong, not the code
mihaela-stoian/constraineddgm/utils.py
code served (permissive licence) · get_code("df25a2473c298d3a")
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 tensor for the input parameter
# The function expects a tensor that supports .clone(), .data assignment, and torch.round()
input_tensor = torch.randn(2, 4, requires_grad=True)

ARGS = {
    "input": input_tensor
}
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
wandb_raw_data Ran
ran; our contract draft was wrong, not the code
mihaela-stoian/constraineddgm/utils.py
code served (permissive licence) · get_code("8c96ded74afe1ddc")
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 Mock. 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 wandb
from unittest.mock import Mock, MagicMock, patch
import pandas as pd
import tempfile
import os

# Create a mock wandb run object that supports the required methods
mock_wandb_run = Mock()
mock_wandb_run.log = Mock()
mock_wandb_run.log_artifact = Mock()

# Mock the wandb module functions
wandb.Table = Mock(return_value=Mock())
wandb.Artifact = Mock(return_value=Mock())

# Create temporary CSV files for the function to read
temp_dir = tempfile.mkdtemp()
os.makedirs(os.path.join(temp_dir, 'data', 'url'), exist_ok=True)

for partition in ['train', 'val', 'test']:
    filename = os.path.join(temp_dir, 'data', 'url', f'{partition}_data.csv')
    df = pd.DataFrame({
        'col1': [1, 2, 3],
        'col2': ['a', 'b', 'c'],
        'col3': [1.1, 2.2, 3.3]
    })
    df.to_csv(filename, index=False)

# Patch os.getcwd to make relative paths work
original_cwd = os.getcwd()
os.chdir(temp_dir)

ARGS = {
    'wandb_run': mock_wandb_run
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pandas, wandb — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Mock — a Mock 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

Also present in other papers' code

Of 10 samples lifted from this paper's linked repositories, 10 carry a function identity and 0 do not. Of the 10 distinct functions with an identity, 1 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 1 later) and 9 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
round_func_BPDA 1 other paper
1 later
2408.07579 (2024-08)
TabularBench: Benchmarking Adversarial Robustness for Tabular Deep Learning in Real-world Use-cases

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

Deep Generative Models (DGMs) have been shown to be powerful tools for generating tabular data, as they have been increasingly able to capture the complex distributions that characterize them. However, to generate realistic synthetic data, it is often not enough to have a good approximation of their distribution, as it also requires compliance with constraints that encode essential background knowledge on the problem at hand. In this paper, we address this limitation and show how DGMs for tabular data can be transformed into Constrained Deep Generative Models (C-DGMs), whose generated samples are guaranteed to be compliant with the given constraints. This is achieved by automatically parsing the constraints and transforming them into a Constraint Layer (CL) seamlessly integrated with the DGM. Our extensive experimental analysis with various DGMs and tasks reveals that standard DGMs often violate constraints, some exceeding 95% noncompliance, while their corresponding C-DGMs are never non-compliant. Then, we quantitatively demonstrate that, at training time, C-DGMs are able to exploit the background knowledge expressed by the constraints to outperform their standard counterparts with up to 6.5% improvement in utility and detection. Further, we show how our CL does not necessarily need to be integrated at training time, as it can be also used as a guardrail at inference time, still producing some improvements in the overall performance of the models. Finally, we show that our CL does not hinder the sample generation time of the models.

For agents

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

get_harvested_code_for_paper("2402.04823")
get_code_for_paper("2402.04823")
have("2402.04823")

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

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

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

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

Connect an agent — have() is free.