diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index be30500c..8ecd8313 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -10,7 +10,7 @@ jobs:
runs-on: ${{ matrix.os }}
strategy:
matrix:
- python-version: ["3.7", "3.8", "3.9", "3.10"]
+ python-version: ["3.8", "3.9", "3.10"]
os: [macos-latest]
steps:
@@ -31,7 +31,6 @@ jobs:
strategy:
matrix:
python-version:
- - cp37-cp37m
- cp38-cp38
- cp39-cp39
- cp310-cp310
@@ -55,7 +54,7 @@ jobs:
runs-on: windows-latest
strategy:
matrix:
- python-version: ["3.7", "3.8", "3.9", "3.10"]
+ python-version: ["3.8", "3.9", "3.10"]
steps:
- uses: actions/checkout@v2
diff --git a/.github/workflows/test_full.yml b/.github/workflows/test_full.yml
index 49346a25..3bd5ea50 100644
--- a/.github/workflows/test_full.yml
+++ b/.github/workflows/test_full.yml
@@ -10,7 +10,7 @@ jobs:
runs-on: ${{ matrix.os }}
strategy:
matrix:
- python-version: ["3.7", "3.8", "3.9", "3.10"]
+ python-version: ["3.8", "3.9", "3.10"]
os: [macos-latest, ubuntu-latest, windows-latest]
steps:
- uses: actions/checkout@v2
diff --git a/.github/workflows/test_tutorials.yml b/.github/workflows/test_tutorials.yml
index ba1c7a4e..5b504b10 100644
--- a/.github/workflows/test_tutorials.yml
+++ b/.github/workflows/test_tutorials.yml
@@ -14,7 +14,7 @@ jobs:
runs-on: ${{ matrix.os }}
strategy:
matrix:
- python-version: ["3.7", "3.8", "3.9", "3.10"]
+ python-version: ["3.8", "3.9", "3.10"]
os: [ubuntu-latest]
steps:
- uses: actions/checkout@v2
@@ -35,7 +35,7 @@ jobs:
python -m pip install -U pip
pip install -r prereq.txt
- pip install .[all]
+ pip install .[testing]
python -m pip install ipykernel
python -m ipykernel install --user
diff --git a/README.md b/README.md
index b3ee37f5..0c4fdd71 100644
--- a/README.md
+++ b/README.md
@@ -460,7 +460,7 @@ First create a new environment. It is recommended that you use conda. This can b
conda create -n your-synthcity-env python=3.9
conda activate your-synthcity-env
```
-*Python versions 3.7, 3.8, 3.9, and 3.10 are all compatible*
+*Python versions 3.7, 3.8, 3.9, and 3.10 are all compatible, but it is best to use the most up to date version you can, as some models may not support older python versions.*
To get the development installation with all the necessary dependencies for
linting, testing, auto-formatting, and pre-commit etc. run the following:
diff --git a/setup.cfg b/setup.cfg
index 54f40eac..3f404642 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -29,18 +29,19 @@ include_package_data = True
package_dir =
=src
-python_requires = >=3.7
+python_requires = >=3.8
install_requires =
+ pandas>=1.4,<2
+ torch>=1.10.0,<2.0
scikit-learn>=1.0
nflows>=0.14
- pandas>=1.3,<2.0
- torch>=1.10.0,<2.0
numpy>=1.20
lifelines>=0.27,!= 0.27.5
opacus>=1.3
decaf-synthetic-data>=0.1.6
optuna>=3.1
+ arfpy @ git+https://github.com/bips-hb/arfpy.git ; python_version >= "3.8" # update to arfpy>=0.1.1 when released
shap
tqdm
loguru
diff --git a/src/synthcity/plugins/core/models/tabular_arf.py b/src/synthcity/plugins/core/models/tabular_arf.py
new file mode 100644
index 00000000..45055957
--- /dev/null
+++ b/src/synthcity/plugins/core/models/tabular_arf.py
@@ -0,0 +1,148 @@
+# stdlib
+from typing import Any, Union
+
+# third party
+import pandas as pd
+import torch
+from pydantic import validate_arguments
+
+try:
+ # third party
+ from arfpy import arf
+except ImportError:
+ raise ImportError(
+ """
+arfpy is not installed. Please install it with pip install arfpy.
+Please be aware that arfpy is only available for python >= 3.8.
+"""
+ )
+# synthcity absolute
+import synthcity.logger as log
+from synthcity.utils.constants import DEVICE
+
+
+class TabularARF:
+ def __init__(
+ self,
+ # ARF parameters
+ X: pd.DataFrame,
+ num_trees: int = 30,
+ delta: int = 0,
+ max_iters: int = 10,
+ early_stop: bool = True,
+ verbose: bool = True,
+ min_node_size: int = 5,
+ # ARF forde parameters
+ dist: str = "truncnorm",
+ oob: bool = False,
+ alpha: float = 0,
+ # core plugin arguments
+ encoder_max_clusters: int = 20,
+ encoder_whitelist: list = [],
+ device: Union[str, torch.device] = DEVICE,
+ learning_rate: float = 5e-3,
+ weight_decay: float = 1e-3,
+ batch_size: int = 32,
+ logging_epoch: int = 100,
+ random_state: int = 0,
+ **kwargs: Any,
+ ):
+ """
+ .. inheritance-diagram:: synthcity.plugins.core.models.tabular_arf.TabularARF
+ :parts: 1
+
+
+ Adversarial random forests for tabular data.
+
+ This class cis a simple wrapper around the arfpy module which implements Adversarial random forests for tabular data.
+
+ Args:
+ # ARF parameters
+ X (pd.DataFrame): Reference dataset, used for training the tabular encoder? # TODO: check if this is needed? Delete?
+ num_trees (int, optional): Number of trees to grow in each forest. Defaults to 30
+ delta (int, optional): Tolerance parameter. Algorithm converges when OOB accuracy is < 0.5 + `delta`. Defaults to 0.
+ max_iters (int, optional): Maximum iterations for the adversarial loop. Defaults to 10.
+ early_stop (bool, optional): Terminate loop if performance fails to improve from one round to the next?. Defaults to True.
+ verbose (bool, optional): Print discriminator accuracy after each round?. Defaults to True.
+ min_node_size (int, optional): minimum number of samples in terminal node. If there is a domain error, when generating, increasing this parameter can fix the issue. Defaults to 5.
+
+ # ARF forde parameters
+ dist (str, optional): Distribution to use for density estimation of continuous features. Distributions implemented so far: "truncnorm", defaults to "truncnorm"
+ oob (bool, optional): Only use out-of-bag samples for parameter estimation? If `True`, `x` must be the same dataset used to train `arf`, defaults to False
+ alpha (float, optional): Optional pseudocount for Laplace smoothing of categorical features. This avoids zero-mass points when test data fall outside the support of training data. Effectively parametrizes a flat Dirichlet prior on multinomial likelihoods, defaults to 0
+
+ # core plugin arguments
+ encoder_max_clusters (int = 20): The max number of clusters to create for continuous columns when encoding with TabularEncoder. Defaults to 20.
+ encoder_whitelist (list = []): Ignore columns from encoding with TabularEncoder. Defaults to [].
+ device: Union[str, torch.device] = DEVICE, # This is not used for this model, as it is built with sklearn, which is cpu only
+ random_state (int, optional): _description_. Defaults to 0. # This is not used for this model
+ **kwargs (Any): The keyword arguments are passed to a SKLearn RandomForestClassifier - https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html.
+ """
+ super(TabularARF, self).__init__()
+ self.columns = X.columns
+ self.num_trees = num_trees
+ self.delta = delta
+ self.max_iters = max_iters
+ self.early_stop = early_stop
+ self.verbose = verbose
+ self.min_node_size = min_node_size
+
+ self.dist = dist
+ self.oob = oob
+ self.alpha = alpha
+
+ def get_categorical_cols(self, X: pd.DataFrame, var_threshold: int) -> list:
+ """
+ Finds columns with a low number of unique values, and returns them as a list.
+ This is used so that the model can treat them as categorical features even if they are numeric.
+ This is important for the ARF model, as it cannot handle zero variance floats in terminal nodes.
+
+ Args:
+ X (pd.DataFrame): The dataframe to check for categorical columns
+ var_threshold (int): The maximum number of unique values a column can have to be considered categorical
+
+ Returns:
+ list: The list of categorical columns
+ """
+ categorical_cols = []
+ for col in X.columns:
+ if X[col].nunique() <= var_threshold:
+ categorical_cols.append(col)
+ return categorical_cols
+
+ @validate_arguments(config=dict(arbitrary_types_allowed=True))
+ def fit(
+ self,
+ X: pd.DataFrame,
+ var_threshold: int = 10,
+ ) -> None:
+ # Make low variance columns are passed as objects
+ object_cols = self.get_categorical_cols(X, var_threshold)
+ for col in object_cols:
+ X[col] = X[col].astype(object)
+
+ self.model = arf.arf(
+ x=X,
+ num_trees=self.num_trees,
+ delta=self.delta,
+ max_iters=self.max_iters,
+ early_stop=self.early_stop,
+ verbose=self.verbose,
+ min_node_size=self.min_node_size,
+ )
+
+ @validate_arguments(config=dict(arbitrary_types_allowed=True))
+ def generate(
+ self,
+ count: int,
+ ) -> pd.DataFrame:
+ self.model.forde(dist=self.dist, oob=self.oob, alpha=self.alpha)
+ try:
+ samples = self.model.forge(n=count)
+ return pd.DataFrame(samples)
+ except Exception as e:
+ log.critical(
+ f"Failed due to error: {e} Try with a higher values of min_node_size."
+ )
+ samples = self.model.forge(n=count)
+ return pd.DataFrame(samples)
diff --git a/src/synthcity/plugins/generic/plugin_arf.py b/src/synthcity/plugins/generic/plugin_arf.py
new file mode 100644
index 00000000..ef90ad68
--- /dev/null
+++ b/src/synthcity/plugins/generic/plugin_arf.py
@@ -0,0 +1,175 @@
+"""
+Reference: "Adversarial random forests for density estimation and generative modeling" Authors: David S. Watson, Kristin Blesch, Jan Kapar, and Marvin N. Wright
+"""
+
+# stdlib
+from pathlib import Path
+from typing import Any, List, Union
+
+# third party
+import pandas as pd
+import torch
+
+# Necessary packages
+from pydantic import validate_arguments
+
+# synthcity absolute
+from synthcity.plugins.core.dataloader import DataLoader
+from synthcity.plugins.core.distribution import (
+ CategoricalDistribution,
+ Distribution,
+ IntegerDistribution,
+)
+from synthcity.plugins.core.models.tabular_arf import TabularARF
+from synthcity.plugins.core.plugin import Plugin
+from synthcity.plugins.core.schema import Schema
+from synthcity.utils.constants import DEVICE
+
+
+class ARFPlugin(Plugin):
+ """
+ .. inheritance-diagram:: synthcity.plugins.generic.plugin_arf.ARFPlugin
+ :parts: 1
+
+ Args:
+
+
+ Example:
+ >>> from sklearn.datasets import load_iris
+ >>> from synthcity.plugins import Plugins
+ >>>
+ >>> X, y = load_iris(as_frame = True, return_X_y = True)
+ >>> X["target"] = y
+ >>>
+ >>> plugin = Plugins().get("arf")
+ >>> plugin.fit(X)
+ >>>
+ >>> plugin.generate(50)
+
+ """
+
+ @validate_arguments(config=dict(arbitrary_types_allowed=True))
+ def __init__(
+ self,
+ # n_iter: int = 1000,
+ num_trees: int = 30,
+ delta: int = 0,
+ max_iters: int = 10,
+ early_stop: bool = True,
+ verbose: bool = True,
+ min_node_size: int = 5,
+ # core plugin arguments
+ device: Union[str, torch.device] = DEVICE,
+ random_state: int = 0,
+ sampling_patience: int = 500,
+ workspace: Path = Path("workspace"),
+ compress_dataset: bool = False,
+ **kwargs: Any,
+ ) -> None:
+ """
+ .. inheritance-diagram:: synthcity.plugins.generic.plugin_arf.ARFPlugin
+ :parts: 1
+
+ Adversarial Random Forest implementation.
+
+ Args:
+ n_iter: int = 1000
+ Maximum number of iterations in the Generator. Defaults to 1000.
+ learning_rate: float = 5e-3
+ Generator learning rate, used by the Adam optimizer. Defaults to 5e-3.
+ weight_decay: float = 1e-3
+ Generator weight decay, used by the Adam optimizer. Defaults to 1e-3.
+ batch_size: int = 32
+ batch size. Defaults to 32.
+ patience: int = 50
+ Max number of iterations without any improvement before early stopping is triggered. Defaults to 50.
+ logging_epoch: int = 100
+ The number of epochs after which information is sent to the debugging level of the logger. Defaults to 100.
+ device: Union[str, torch.device] = synthcity.utils.constants.DEVICE
+ The device that the model is run on. Defaults to "cuda" if cuda is available else "cpu".
+ random_state: int = 0
+ random_state used. Defaults to 0.
+ sampling_patience: int = 500
+ Max inference iterations to wait for the generated data to match the training schema. Defaults to 500.
+ workspace: Path
+ Path for caching intermediary results. Defaults to Path("workspace").
+ compress_dataset: bool. Default = False
+ Drop redundant features before training the generator. Defaults to False.
+ dataloader_sampler: Any = None
+ Optional sampler for the dataloader. Defaults to None.
+ """
+ super().__init__(
+ device=device,
+ random_state=random_state,
+ sampling_patience=sampling_patience,
+ workspace=workspace,
+ compress_dataset=compress_dataset,
+ **kwargs,
+ )
+ self.num_trees = num_trees
+ self.delta = delta
+ self.max_iters = max_iters
+ self.early_stop = early_stop
+ self.verbose = verbose
+ self.min_node_size = min_node_size
+
+ @staticmethod
+ def name() -> str:
+ return "arf"
+
+ @staticmethod
+ def type() -> str:
+ return "generic"
+
+ @staticmethod
+ def hyperparameter_space(**kwargs: Any) -> List[Distribution]:
+ return [
+ IntegerDistribution(name="num_trees", low=10, high=100, step=10),
+ IntegerDistribution(
+ name="delta", low=0, high=50, step=2
+ ), # TODO: check if this is the right range
+ IntegerDistribution(name="max_iters", low=1, high=5, step=1),
+ CategoricalDistribution(name="early_stop", choices=[True, False]),
+ IntegerDistribution(name="min_node_size", low=2, high=20, step=2),
+ ]
+
+ def _fit(self, X: DataLoader, *args: Any, **kwargs: Any) -> "ARFPlugin":
+ """_summary_
+
+ Args:
+ X (DataLoader): _description_
+ kwargs (Any): keyword arguments passed on to an SKLearn RandomForestClassifier
+
+ Raises:
+ NotImplementedError: _description_
+
+ Returns:
+ ARFPlugin: _description_
+ """
+ self.model = TabularARF(
+ X.dataframe(),
+ self.num_trees,
+ self.delta,
+ self.max_iters,
+ self.early_stop,
+ self.verbose,
+ self.min_node_size,
+ **kwargs,
+ )
+ if "cond" in kwargs and kwargs["cond"] is not None:
+ raise NotImplementedError(
+ "conditional generation is not currently available for the Adversarial Random Forest (ARF) plugin."
+ )
+ self.model.fit(X.dataframe(), **kwargs)
+ return self
+
+ def _generate(self, count: int, syn_schema: Schema, **kwargs: Any) -> pd.DataFrame:
+ if "cond" in kwargs and kwargs["cond"] is not None:
+ raise NotImplementedError(
+ "conditional generation is not currently available for the goggle plugin."
+ )
+
+ return self._safe_generate(self.model.generate, count, syn_schema)
+
+
+plugin = ARFPlugin
diff --git a/src/synthcity/version.py b/src/synthcity/version.py
index f97c1077..3ff18fd8 100644
--- a/src/synthcity/version.py
+++ b/src/synthcity/version.py
@@ -1,4 +1,4 @@
-__version__ = "0.2.6"
+__version__ = "0.2.7"
MAJOR_VERSION = ".".join(__version__.split(".")[:-1])
PATCH_VERSION = __version__.split(".")[-1]
diff --git a/tests/plugins/generic/test_arf.py b/tests/plugins/generic/test_arf.py
new file mode 100644
index 00000000..45026797
--- /dev/null
+++ b/tests/plugins/generic/test_arf.py
@@ -0,0 +1,169 @@
+# stdlib
+import random
+from datetime import datetime, timedelta
+
+# third party
+import numpy as np
+import pandas as pd
+import pytest
+from generic_helpers import generate_fixtures, get_airfoil_dataset
+from sklearn.datasets import load_diabetes, load_iris
+
+# synthcity absolute
+from synthcity.metrics.eval import PerformanceEvaluatorXGB
+from synthcity.plugins import Plugin
+from synthcity.plugins.core.constraints import Constraints
+from synthcity.plugins.core.dataloader import GenericDataLoader
+from synthcity.plugins.generic.plugin_arf import plugin
+from synthcity.utils.serialization import load, save
+
+plugin_name = "arf"
+plugin_args = {
+ "num_trees": 10,
+ "delta": 0,
+ "max_iters": 15,
+ "early_stop": True,
+ "verbose": True,
+ "min_node_size": 10,
+}
+
+
+@pytest.mark.parametrize("test_plugin", generate_fixtures(plugin_name, plugin))
+def test_plugin_sanity(test_plugin: Plugin) -> None:
+ assert test_plugin is not None
+
+
+@pytest.mark.parametrize("test_plugin", generate_fixtures(plugin_name, plugin))
+def test_plugin_name(test_plugin: Plugin) -> None:
+ assert test_plugin.name() == plugin_name
+
+
+@pytest.mark.parametrize("test_plugin", generate_fixtures(plugin_name, plugin))
+def test_plugin_type(test_plugin: Plugin) -> None:
+ assert test_plugin.type() == "generic"
+
+
+@pytest.mark.parametrize("test_plugin", generate_fixtures(plugin_name, plugin))
+def test_plugin_hyperparams(test_plugin: Plugin) -> None:
+ assert len(test_plugin.hyperparameter_space()) == 5
+
+
+@pytest.mark.parametrize(
+ "test_plugin", generate_fixtures(plugin_name, plugin, plugin_args)
+)
+def test_plugin_fit(test_plugin: Plugin) -> None:
+ X = get_airfoil_dataset()
+ test_plugin.fit(GenericDataLoader(X))
+
+
+@pytest.mark.parametrize(
+ "test_plugin",
+ generate_fixtures(plugin_name, plugin, plugin_args),
+)
+@pytest.mark.parametrize("serialize", [True, False])
+def test_plugin_generate(test_plugin: Plugin, serialize: bool) -> None:
+ X, y = load_diabetes(return_X_y=True, as_frame=True)
+ X["target"] = y
+ test_plugin.fit(GenericDataLoader(X))
+
+ if serialize:
+ saved = save(test_plugin)
+ test_plugin = load(saved)
+
+ X_gen = test_plugin.generate()
+ assert len(X_gen) == len(X)
+ assert X_gen.shape[1] == X.shape[1]
+ assert test_plugin.schema_includes(X_gen)
+
+ X_gen = test_plugin.generate(50)
+ assert len(X_gen) == 50
+ assert test_plugin.schema_includes(X_gen)
+
+ # generate with random seed
+ X_gen1 = test_plugin.generate(50, random_state=0)
+ X_gen2 = test_plugin.generate(50, random_state=0)
+ X_gen3 = test_plugin.generate(50)
+ assert (X_gen1.numpy() == X_gen2.numpy()).all()
+ assert (X_gen1.numpy() != X_gen3.numpy()).any()
+
+
+@pytest.mark.parametrize(
+ "test_plugin", generate_fixtures(plugin_name, plugin, plugin_args)
+)
+def test_plugin_generate_constraints_arf(test_plugin: Plugin) -> None:
+ X, y = load_iris(as_frame=True, return_X_y=True)
+ X["target"] = y
+ test_plugin.fit(GenericDataLoader(X))
+
+ constraints = Constraints(
+ rules=[
+ ("target", "eq", 1),
+ ]
+ )
+
+ X_gen = test_plugin.generate(constraints=constraints).dataframe()
+ assert len(X_gen) == len(X)
+ assert test_plugin.schema_includes(X_gen)
+ assert constraints.filter(X_gen).sum() == len(X_gen)
+ assert (X_gen["target"] == 1).all()
+
+ X_gen = test_plugin.generate(count=50, constraints=constraints).dataframe()
+ assert len(X_gen) == 50
+ assert test_plugin.schema_includes(X_gen)
+ assert constraints.filter(X_gen).sum() == len(X_gen)
+ assert list(X_gen.columns) == list(X.columns)
+
+
+def test_sample_hyperparams() -> None:
+ for i in range(100):
+ args = plugin.sample_hyperparameters()
+ assert plugin(**args) is not None
+
+
+@pytest.mark.slow
+@pytest.mark.parametrize("compress_dataset", [True, False])
+def test_eval_performance_arf(compress_dataset: bool) -> None:
+ results = []
+
+ Xraw, y = load_iris(return_X_y=True, as_frame=True)
+ Xraw["target"] = y
+ X = GenericDataLoader(Xraw)
+
+ for retry in range(2):
+ test_plugin = plugin(**plugin_args)
+ evaluator = PerformanceEvaluatorXGB()
+
+ test_plugin.fit(X)
+ X_syn = test_plugin.generate(count=100)
+
+ results.append(evaluator.evaluate(X, X_syn)["syn_id"])
+
+ print(plugin.name(), compress_dataset, results)
+ assert np.mean(results) > 0.7
+
+
+def gen_datetime(min_year: int = 2000, max_year: int = datetime.now().year) -> datetime:
+ # generate a datetime in format yyyy-mm-dd hh:mm:ss.000000
+ start = datetime(min_year, 1, 1, 00, 00, 00)
+ years = max_year - min_year + 1
+ end = start + timedelta(days=365 * years)
+ return start + (end - start) * random.random()
+
+
+@pytest.mark.slow
+def test_plugin_encoding() -> None:
+ data = [[gen_datetime(), i % 2 == 0, i] for i in range(1000)]
+
+ df = pd.DataFrame(data, columns=["date", "bool", "int"])
+ test_plugin = plugin(**plugin_args)
+ test_plugin.fit(df)
+
+ syn = test_plugin.generate(10)
+
+ assert len(syn) == 10
+ assert test_plugin.schema_includes(syn)
+
+ syn_df = syn.dataframe()
+
+ assert syn_df["date"].infer_objects().dtype.kind == "M"
+ assert syn_df["bool"].infer_objects().dtype.kind == "b"
diff --git a/tutorials/plugins/generic/plugin_arf.ipynb b/tutorials/plugins/generic/plugin_arf.ipynb
new file mode 100644
index 00000000..ab09a71c
--- /dev/null
+++ b/tutorials/plugins/generic/plugin_arf.ipynb
@@ -0,0 +1,758 @@
+{
+ "cells": [
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Adversarial Random Forest"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# stdlib\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")\n",
+ "\n",
+ "# third party\n",
+ "from sklearn.datasets import load_iris, load_diabetes\n",
+ "from arfpy import arf\n",
+ "\n",
+ "# synthcity absolute\n",
+ "from synthcity.plugins import Plugins\n",
+ "\n",
+ "eval_plugin = \"arf\""
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Load dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " age | \n",
+ " sex | \n",
+ " bmi | \n",
+ " bp | \n",
+ " s1 | \n",
+ " s2 | \n",
+ " s3 | \n",
+ " s4 | \n",
+ " s5 | \n",
+ " s6 | \n",
+ " target | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 0.038076 | \n",
+ " 0.050680 | \n",
+ " 0.061696 | \n",
+ " 0.021872 | \n",
+ " -0.044223 | \n",
+ " -0.034821 | \n",
+ " -0.043401 | \n",
+ " -0.002592 | \n",
+ " 0.019907 | \n",
+ " -0.017646 | \n",
+ " 151.0 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " -0.001882 | \n",
+ " -0.044642 | \n",
+ " -0.051474 | \n",
+ " -0.026328 | \n",
+ " -0.008449 | \n",
+ " -0.019163 | \n",
+ " 0.074412 | \n",
+ " -0.039493 | \n",
+ " -0.068332 | \n",
+ " -0.092204 | \n",
+ " 75.0 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 0.085299 | \n",
+ " 0.050680 | \n",
+ " 0.044451 | \n",
+ " -0.005670 | \n",
+ " -0.045599 | \n",
+ " -0.034194 | \n",
+ " -0.032356 | \n",
+ " -0.002592 | \n",
+ " 0.002861 | \n",
+ " -0.025930 | \n",
+ " 141.0 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " -0.089063 | \n",
+ " -0.044642 | \n",
+ " -0.011595 | \n",
+ " -0.036656 | \n",
+ " 0.012191 | \n",
+ " 0.024991 | \n",
+ " -0.036038 | \n",
+ " 0.034309 | \n",
+ " 0.022688 | \n",
+ " -0.009362 | \n",
+ " 206.0 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 0.005383 | \n",
+ " -0.044642 | \n",
+ " -0.036385 | \n",
+ " 0.021872 | \n",
+ " 0.003935 | \n",
+ " 0.015596 | \n",
+ " 0.008142 | \n",
+ " -0.002592 | \n",
+ " -0.031988 | \n",
+ " -0.046641 | \n",
+ " 135.0 | \n",
+ "
\n",
+ " \n",
+ " | ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ "
\n",
+ " \n",
+ " | 437 | \n",
+ " 0.041708 | \n",
+ " 0.050680 | \n",
+ " 0.019662 | \n",
+ " 0.059744 | \n",
+ " -0.005697 | \n",
+ " -0.002566 | \n",
+ " -0.028674 | \n",
+ " -0.002592 | \n",
+ " 0.031193 | \n",
+ " 0.007207 | \n",
+ " 178.0 | \n",
+ "
\n",
+ " \n",
+ " | 438 | \n",
+ " -0.005515 | \n",
+ " 0.050680 | \n",
+ " -0.015906 | \n",
+ " -0.067642 | \n",
+ " 0.049341 | \n",
+ " 0.079165 | \n",
+ " -0.028674 | \n",
+ " 0.034309 | \n",
+ " -0.018114 | \n",
+ " 0.044485 | \n",
+ " 104.0 | \n",
+ "
\n",
+ " \n",
+ " | 439 | \n",
+ " 0.041708 | \n",
+ " 0.050680 | \n",
+ " -0.015906 | \n",
+ " 0.017293 | \n",
+ " -0.037344 | \n",
+ " -0.013840 | \n",
+ " -0.024993 | \n",
+ " -0.011080 | \n",
+ " -0.046883 | \n",
+ " 0.015491 | \n",
+ " 132.0 | \n",
+ "
\n",
+ " \n",
+ " | 440 | \n",
+ " -0.045472 | \n",
+ " -0.044642 | \n",
+ " 0.039062 | \n",
+ " 0.001215 | \n",
+ " 0.016318 | \n",
+ " 0.015283 | \n",
+ " -0.028674 | \n",
+ " 0.026560 | \n",
+ " 0.044529 | \n",
+ " -0.025930 | \n",
+ " 220.0 | \n",
+ "
\n",
+ " \n",
+ " | 441 | \n",
+ " -0.045472 | \n",
+ " -0.044642 | \n",
+ " -0.073030 | \n",
+ " -0.081413 | \n",
+ " 0.083740 | \n",
+ " 0.027809 | \n",
+ " 0.173816 | \n",
+ " -0.039493 | \n",
+ " -0.004222 | \n",
+ " 0.003064 | \n",
+ " 57.0 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
442 rows × 11 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " age | \n",
+ " sex | \n",
+ " bmi | \n",
+ " bp | \n",
+ " s1 | \n",
+ " s2 | \n",
+ " s3 | \n",
+ " s4 | \n",
+ " s5 | \n",
+ " s6 | \n",
+ " target | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " -0.086393 | \n",
+ " -0.044642 | \n",
+ " 0.007827 | \n",
+ " -0.082694 | \n",
+ " -0.070826 | \n",
+ " -0.031689 | \n",
+ " -0.022770 | \n",
+ " -0.040690 | \n",
+ " -0.060941 | \n",
+ " -0.004776 | \n",
+ " 151.946358 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 0.095274 | \n",
+ " -0.044642 | \n",
+ " 0.105097 | \n",
+ " -0.017663 | \n",
+ " 0.015564 | \n",
+ " 0.063357 | \n",
+ " -0.014695 | \n",
+ " 0.049971 | \n",
+ " -0.000491 | \n",
+ " 0.086407 | \n",
+ " 173.325625 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " -0.093247 | \n",
+ " 0.050680 | \n",
+ " 0.002027 | \n",
+ " 0.010936 | \n",
+ " 0.031776 | \n",
+ " 0.078785 | \n",
+ " -0.036780 | \n",
+ " 0.069716 | \n",
+ " 0.054071 | \n",
+ " -0.022569 | \n",
+ " 93.216366 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " -0.003044 | \n",
+ " -0.044642 | \n",
+ " -0.011851 | \n",
+ " 0.042983 | \n",
+ " 0.050315 | \n",
+ " 0.015271 | \n",
+ " -0.029527 | \n",
+ " 0.081901 | \n",
+ " 0.036231 | \n",
+ " -0.030540 | \n",
+ " 247.961946 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 0.046480 | \n",
+ " -0.044642 | \n",
+ " 0.008256 | \n",
+ " 0.014460 | \n",
+ " 0.076982 | \n",
+ " 0.032764 | \n",
+ " -0.023157 | \n",
+ " 0.055037 | \n",
+ " 0.043250 | \n",
+ " -0.009325 | \n",
+ " 197.697742 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 0.010281 | \n",
+ " -0.044642 | \n",
+ " -0.074313 | \n",
+ " -0.018122 | \n",
+ " -0.061187 | \n",
+ " 0.007181 | \n",
+ " 0.037822 | \n",
+ " -0.043901 | \n",
+ " -0.000467 | \n",
+ " 0.018067 | \n",
+ " 112.687665 | \n",
+ "
\n",
+ " \n",
+ " | 6 | \n",
+ " 0.013900 | \n",
+ " -0.044642 | \n",
+ " 0.094329 | \n",
+ " -0.002838 | \n",
+ " 0.029468 | \n",
+ " 0.015944 | \n",
+ " -0.043888 | \n",
+ " 0.088412 | \n",
+ " 0.112952 | \n",
+ " 0.063410 | \n",
+ " 290.921132 | \n",
+ "
\n",
+ " \n",
+ " | 7 | \n",
+ " 0.028002 | \n",
+ " 0.050680 | \n",
+ " 0.004196 | \n",
+ " -0.012448 | \n",
+ " -0.049430 | \n",
+ " 0.000453 | \n",
+ " 0.015044 | \n",
+ " 0.048480 | \n",
+ " 0.014182 | \n",
+ " -0.006435 | \n",
+ " 108.241937 | \n",
+ "
\n",
+ " \n",
+ " | 8 | \n",
+ " 0.077659 | \n",
+ " -0.044642 | \n",
+ " 0.025821 | \n",
+ " -0.026111 | \n",
+ " -0.063871 | \n",
+ " -0.024846 | \n",
+ " -0.035111 | \n",
+ " 0.018119 | \n",
+ " 0.027371 | \n",
+ " -0.031979 | \n",
+ " 163.642922 | \n",
+ "
\n",
+ " \n",
+ " | 9 | \n",
+ " -0.015496 | \n",
+ " -0.044642 | \n",
+ " 0.029851 | \n",
+ " -0.044488 | \n",
+ " 0.015254 | \n",
+ " 0.038776 | \n",
+ " -0.012563 | \n",
+ " 0.180835 | \n",
+ " 0.053852 | \n",
+ " -0.014664 | \n",
+ " 211.509308 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# third party\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "syn_model.plot(plt, loader, count=100)\n",
+ "\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "attachments": {},
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Benchmarks"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Initial accuracy is 0.7960339943342776\n",
+ "Iteration number 1 reached accuracy of 0.3654390934844193.\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2023-06-01T12:48:11.864152+0100][13928][CRITICAL] [arf][take 0] failed: Domain error in arguments. The `scale` parameter must be positive for all distributions, and many distributions have restrictions on shape parameters. Please see the `scipy.stats.truncnorm` documentation for details.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Initial accuracy is 0.8116147308781869\n",
+ "Iteration number 1 reached accuracy of 0.3526912181303116.\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2023-06-01T12:48:15.490117+0100][13928][CRITICAL] [arf][take 1] failed: Domain error in arguments. The `scale` parameter must be positive for all distributions, and many distributions have restrictions on shape parameters. Please see the `scipy.stats.truncnorm` documentation for details.\n"
+ ]
+ }
+ ],
+ "source": [
+ "# synthcity absolute\n",
+ "from synthcity.benchmark import Benchmarks\n",
+ "\n",
+ "score = Benchmarks.evaluate(\n",
+ " [\n",
+ " (eval_plugin, eval_plugin, {\"num_trees\": 100, \"delta\": 0, \"max_iters\":15, \"early_stop\": True, \"verbose\": True, \"min_node_size\": 3})\n",
+ " ], # (testname, plugin, plugin_args) The plugin_args are given are simply to illustrate some of the paramters that can be passed to the plugin\n",
+ " loader,\n",
+ " repeats=2,\n",
+ " metrics={\"detection\": [\"detection_mlp\"]}, # DELETE THIS LINE FOR ALL METRICS\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "\u001b[4m\u001b[1mPlugin : arf\u001b[0m\u001b[0m\n"
+ ]
+ },
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " min | \n",
+ " max | \n",
+ " mean | \n",
+ " stddev | \n",
+ " median | \n",
+ " iqr | \n",
+ " rounds | \n",
+ " errors | \n",
+ " durations | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "