classifier_comparison.rst

Scikit-learn Classifier Comparison

Original Code

Dependencies

For this example, you will need:

• https://scikit-learn.org/stable/install.html

This example adapts the classifier comparison example from the scikit-learn documentation to use ZnTrack.

The original code looks like this:

Original Code

# Authors: The scikit-learn developers
# SPDX-License-Identifier: BSD-3-Clause

import matplotlib.pyplot as plt
import numpy as np
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_circles, make_classification, make_moons
from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.inspection import DecisionBoundaryDisplay
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier

names = [
    "Nearest Neighbors",
    "Linear SVM",
    "RBF SVM",
    "Gaussian Process",
    "Decision Tree",
    "Random Forest",
    "Neural Net",
    "AdaBoost",
    "Naive Bayes",
    "QDA",
]

classifiers = [
    KNeighborsClassifier(3),
    SVC(kernel="linear", C=0.025, random_state=42),
    SVC(gamma=2, C=1, random_state=42),
    GaussianProcessClassifier(1.0 * RBF(1.0), random_state=42),
    DecisionTreeClassifier(max_depth=5, random_state=42),
    RandomForestClassifier(max_depth=5, n_estimators=10, max_features=1, random_state=42),
    MLPClassifier(alpha=1, max_iter=1000, random_state=42),
    AdaBoostClassifier(random_state=42),
    GaussianNB(),
    QuadraticDiscriminantAnalysis(),
]

X, y = make_classification(
    n_features=2, n_redundant=0, n_informative=2, random_state=1, n_clusters_per_class=1
)
rng = np.random.RandomState(2)
X += 2 * rng.uniform(size=X.shape)
linearly_separable = (X, y)

datasets = [
    make_moons(noise=0.3, random_state=0),
    make_circles(noise=0.2, factor=0.5, random_state=1),
    linearly_separable,
]

figure = plt.figure(figsize=(27, 9))
i = 1
# iterate over datasets
for ds_cnt, ds in enumerate(datasets):
    # preprocess dataset, split into training and test part
    X, y = ds
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.4, random_state=42
    )

    x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
    y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5

    # just plot the dataset first
    cm = plt.cm.RdBu
    cm_bright = ListedColormap(["#FF0000", "#0000FF"])
    ax = plt.subplot(len(datasets), len(classifiers) + 1, i)
    if ds_cnt == 0:
        ax.set_title("Input data")
    # Plot the training points
    ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k")
    # Plot the testing points
    ax.scatter(
        X_test[:, 0], X_test[:, 1], c=y_test, cmap=cm_bright, alpha=0.6, edgecolors="k"
    )
    ax.set_xlim(x_min, x_max)
    ax.set_ylim(y_min, y_max)
    ax.set_xticks(())
    ax.set_yticks(())
    i += 1

    # iterate over classifiers
    for name, clf in zip(names, classifiers):
        ax = plt.subplot(len(datasets), len(classifiers) + 1, i)

        clf = make_pipeline(StandardScaler(), clf)
        clf.fit(X_train, y_train)
        score = clf.score(X_test, y_test)
        DecisionBoundaryDisplay.from_estimator(clf, X, cmap=cm, alpha=0.8, ax=ax, eps=0.5)

        # Plot the training points
        ax.scatter(
            X_train[:, 0], X_train[:, 1], c=y_train, cmap=cm_bright, edgecolors="k"
        )
        # Plot the testing points
        ax.scatter(
            X_test[:, 0],
            X_test[:, 1],
            c=y_test,
            cmap=cm_bright,
            edgecolors="k",
            alpha=0.6,
        )

        ax.set_xlim(x_min, x_max)
        ax.set_ylim(y_min, y_max)
        ax.set_xticks(())
        ax.set_yticks(())
        if ds_cnt == 0:
            ax.set_title(name)
        ax.text(
            x_max - 0.3,
            y_min + 0.3,
            ("%.2f" % score).lstrip("0"),
            size=15,
            horizontalalignment="right",
        )
        i += 1

plt.tight_layout()
plt.show()

Converted Workflow with ZnTrack

We adapt the scikit-learn example to utilize ZnTrack. This allows us to store, share results, and reuse the code by better separating it into individual Node instances for each task. Additionally, we can optimize parameters and compare different classifiers more effectively using DVC infrastructure tools.

Here’s the graph structure for a single dataset and multiple classifiers:

        flowchart TD

Dataset --> TrainTestSplit
subgraph Classifier
    KNeighborsClassifier
    SVC
    GaussianProcessClassifier
    DecisionTreeClassifier
    RandomForestClassifier
    a["..."]
end
TrainTestSplit --> KNeighborsClassifier --> Compare
TrainTestSplit --> SVC --> Compare
TrainTestSplit --> GaussianProcessClassifier --> Compare
TrainTestSplit --> DecisionTreeClassifier --> Compare
TrainTestSplit --> RandomForestClassifier --> Compare
TrainTestSplit --> a["..."] --> Compare
    

ZnTrack Nodes

import dataclasses
import typing as t
from pathlib import Path

import zntrack


class CreateDataset(zntrack.Node):
    params: dict = zntrack.params(default_factory=dict)
    method: t.Literal["make_moons", "make_circles", "linearly_separable"] = (
        zntrack.params()
    )

    x: t.Any = zntrack.outs()
    y: t.Any = zntrack.outs()

    def run(self) -> None:
        import numpy as np
        from sklearn.datasets import make_circles, make_classification, make_moons

        if self.method == "make_moons":
            self.x, self.y = make_moons(**self.params)
        elif self.method == "make_circles":
            self.x, self.y = make_circles(**self.params)
        elif self.method == "linearly_separable":
            X, y = make_classification(**self.params)
            rng = np.random.RandomState(2)
            X += 2 * rng.uniform(size=X.shape)
            self.x, self.y = X, y
        else:
            raise ValueError(f"Unknown method: {self.method}")


class TrainTestSplit(zntrack.Node):
    x: t.Any = zntrack.deps()
    y: t.Any = zntrack.deps()

    x_train: t.Any = zntrack.outs()
    y_train: t.Any = zntrack.outs()
    x_test: t.Any = zntrack.outs()
    y_test: t.Any = zntrack.outs()

    test_size: float = zntrack.params(0.4)
    random_state: int = zntrack.params(42)

    def run(self) -> None:
        from sklearn.model_selection import train_test_split

        self.x_train, self.x_test, self.y_train, self.y_test = train_test_split(
            self.x, self.y, test_size=self.test_size, random_state=self.random_state
        )


@dataclasses.dataclass
class Model:
    method: t.Literal[
        "KNeighborsClassifier",
        "SVC",
        "GaussianProcessClassifier",
        "DecisionTreeClassifier",
        "RandomForestClassifier",
        "MLPClassifier",
        "AdaBoostClassifier",
        "GaussianNB",
        "QuadraticDiscriminantAnalysis",
    ]
    params: dict = dataclasses.field(default_factory=dict)
    name: str | None = None

    def __post_init__(self):
        if self.name is None:
            self.name = self.method

    def get_model(self):
        from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis
        from sklearn.ensemble import AdaBoostClassifier, RandomForestClassifier
        from sklearn.gaussian_process import GaussianProcessClassifier
        from sklearn.gaussian_process.kernels import RBF
        from sklearn.naive_bayes import GaussianNB
        from sklearn.neighbors import KNeighborsClassifier
        from sklearn.neural_network import MLPClassifier
        from sklearn.svm import SVC
        from sklearn.tree import DecisionTreeClassifier

        if self.method == "KNeighborsClassifier":
            return KNeighborsClassifier(**self.params)
        elif self.method == "SVC":
            return SVC(**self.params)
        elif self.method == "GaussianProcessClassifier":
            kernel = 1.0 * RBF(1.0)
            return GaussianProcessClassifier(kernel=kernel, **self.params)
        elif self.method == "DecisionTreeClassifier":
            return DecisionTreeClassifier(**self.params)
        elif self.method == "RandomForestClassifier":
            return RandomForestClassifier(**self.params)
        elif self.method == "MLPClassifier":
            return MLPClassifier(**self.params)
        elif self.method == "AdaBoostClassifier":
            return AdaBoostClassifier(**self.params)
        elif self.method == "GaussianNB":
            return GaussianNB(**self.params)
        elif self.method == "QuadraticDiscriminantAnalysis":
            return QuadraticDiscriminantAnalysis(**self.params)
        else:
            raise ValueError(f"Unknown method: {self.method}")


class Classifier(zntrack.Node):
    model: Model = zntrack.deps()

    x: t.Any = zntrack.deps()

    x_train: t.Any = zntrack.deps()
    y_train: t.Any = zntrack.deps()

    x_test: t.Any = zntrack.deps()
    y_test: t.Any = zntrack.deps()

    metrics: dict = zntrack.metrics()

    figure_path: Path = zntrack.plots_path(zntrack.nwd / "figure.png")

    def run(self):
        model = self.model.get_model()
        model.fit(self.x_train, self.y_train)

        self.metrics = {"score": model.score(self.x_test, self.y_test)}
        self.get_figure(model)

    def get_figure(self, clf):
        import matplotlib.pyplot as plt
        from matplotlib.colors import ListedColormap
        from sklearn.inspection import DecisionBoundaryDisplay

        fig, ax = plt.subplots()

        x_min, x_max = self.x[:, 0].min() - 0.5, self.x[:, 0].max() + 0.5
        y_min, y_max = self.x[:, 1].min() - 0.5, self.x[:, 1].max() + 0.5

        cm = plt.cm.RdBu
        cm_bright = ListedColormap(["#FF0000", "#0000FF"])

        DecisionBoundaryDisplay.from_estimator(
            clf, self.x, cmap=cm, alpha=0.8, ax=ax, eps=0.5
        )

        # Plot the training points
        ax.scatter(
            self.x_train[:, 0],
            self.x_train[:, 1],
            c=self.y_train,
            cmap=cm_bright,
            edgecolors="k",
        )
        # Plot the testing points
        ax.scatter(
            self.x_test[:, 0],
            self.x_test[:, 1],
            c=self.y_test,
            cmap=cm_bright,
            edgecolors="k",
            alpha=0.6,
        )

        ax.set_xlim(x_min, x_max)
        ax.set_ylim(y_min, y_max)
        ax.set_xticks(())
        ax.set_yticks(())

        self.figure_path.parent.mkdir(exist_ok=True, parents=True)
        fig.savefig(self.figure_path, bbox_inches="tight")


class CombineFigures(zntrack.Node):
    cfs: list[Classifier] = zntrack.deps()
    combined_figure_path: Path = zntrack.plots_path(zntrack.nwd / "combined_figure.png")

    def run(self):
        import matplotlib.pyplot as plt
        import numpy as np
        from PIL import Image

        # Determine grid size
        n_cols = int(len(self.cfs) ** 0.5)
        n_rows = (len(self.cfs) + n_cols - 1) // n_cols

        # Create figure with tight spacing
        fig, axs = plt.subplots(n_rows, n_cols, figsize=(n_cols * 4, n_rows * 4))
        axs = np.array(axs).reshape(n_rows, n_cols)  # Ensure axs is always iterable

        # Remove unnecessary padding
        fig.subplots_adjust(left=0, right=1, top=1, bottom=0, wspace=0, hspace=0.0)

        # Display images
        for i, cf in enumerate(self.cfs):
            img = Image.open(cf.figure_path)
            ax = axs[i // n_cols, i % n_cols]
            ax.imshow(img)
            ax.set_title(
                f"{cf.model.name} - {cf.metrics['score']:.2f}", fontsize=10, pad=2
            )
            ax.axis("off")

        # Hide unused axes
        for i in range(len(self.cfs), n_cols * n_rows):
            axs[i // n_cols, i % n_cols].axis("off")

        fig.savefig(self.combined_figure_path, bbox_inches="tight", pad_inches=0.1)

ZnTrack Workflow

import zntrack

# Store all outputs in the DVC cache and avoid GIT tracked Node outputs.
zntrack.config.ALWAYS_CACHE = True

from src import Classifier, CombineFigures, CreateDataset, Model, TrainTestSplit

project = zntrack.Project()

models = [
    Model(
        method="KNeighborsClassifier",
        params={"n_neighbors": 3},
    ),
    Model(
        method="SVC",
        params={"kernel": "linear", "C": 0.025, "random_state": 42},
        name="Linear-SVM",
    ),
    Model(
        method="SVC",
        params={"gamma": 2, "C": 1, "random_state": 42},
        name="RBF-SVM",
    ),
    Model(
        method="GaussianProcessClassifier",
        params={"random_state": 42},
    ),
    Model(
        method="DecisionTreeClassifier",
        params={"max_depth": 5, "random_state": 42},
    ),
    Model(
        method="RandomForestClassifier",
        params={
            "max_depth": 5,
            "n_estimators": 10,
            "max_features": 1,
            "random_state": 42,
        },
    ),
    Model(
        method="MLPClassifier",
        params={"alpha": 1, "max_iter": 1000, "random_state": 42},
    ),
    Model(
        method="AdaBoostClassifier",
        params={"random_state": 42},
    ),
    Model(
        method="GaussianNB",
    ),
    Model(
        method="QuadraticDiscriminantAnalysis",
    ),
]


def classify(ds):
    split = TrainTestSplit(x=ds.x, y=ds.y)

    cfs = []

    for model in models:
        cfs.append(
            Classifier(
                model=model,
                x=ds.x,
                x_train=split.x_train,
                y_train=split.y_train,
                x_test=split.x_test,
                y_test=split.y_test,
                name=model.name,
            )
        )

    CombineFigures(cfs=cfs)


with project.group("moons"):
    ds = CreateDataset(method="make_moons", params={"noise": 0.3, "random_state": 0})
    classify(ds)

with project.group("circles"):
    ds = CreateDataset(
        method="make_circles", params={"noise": 0.2, "factor": 0.5, "random_state": 0}
    )
    classify(ds)

with project.group("linearly-separable"):
    ds = CreateDataset(
        method="linearly_separable",
        params={
            "n_features": 2,
            "n_redundant": 0,
            "n_informative": 2,
            "random_state": 42,
            "n_clusters_per_class": 1,
        },
    )
    classify(ds)

project.repro()

Generated configuration files

dvc.yaml File

stages:
  circles_AdaBoostClassifier:
    cmd: zntrack run src.Classifier --name circles_AdaBoostClassifier
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/AdaBoostClassifier/metrics.json
    - nodes/circles/AdaBoostClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/circles/AdaBoostClassifier/figure.png
    params:
    - circles_AdaBoostClassifier
  circles_CombineFigures:
    cmd: zntrack run src.CombineFigures --name circles_CombineFigures
    deps:
    - nodes/circles/AdaBoostClassifier/figure.png
    - nodes/circles/AdaBoostClassifier/metrics.json
    - nodes/circles/DecisionTreeClassifier/figure.png
    - nodes/circles/DecisionTreeClassifier/metrics.json
    - nodes/circles/GaussianNB/figure.png
    - nodes/circles/GaussianNB/metrics.json
    - nodes/circles/GaussianProcessClassifier/figure.png
    - nodes/circles/GaussianProcessClassifier/metrics.json
    - nodes/circles/KNeighborsClassifier/figure.png
    - nodes/circles/KNeighborsClassifier/metrics.json
    - nodes/circles/Linear-SVM/figure.png
    - nodes/circles/Linear-SVM/metrics.json
    - nodes/circles/MLPClassifier/figure.png
    - nodes/circles/MLPClassifier/metrics.json
    - nodes/circles/QuadraticDiscriminantAnalysis/figure.png
    - nodes/circles/QuadraticDiscriminantAnalysis/metrics.json
    - nodes/circles/RBF-SVM/figure.png
    - nodes/circles/RBF-SVM/metrics.json
    - nodes/circles/RandomForestClassifier/figure.png
    - nodes/circles/RandomForestClassifier/metrics.json
    metrics:
    - nodes/circles/CombineFigures/node-meta.json:
        cache: true
    outs:
    - nodes/circles/CombineFigures/combined_figure.png
  circles_CreateDataset:
    cmd: zntrack run src.CreateDataset --name circles_CreateDataset
    metrics:
    - nodes/circles/CreateDataset/node-meta.json:
        cache: true
    outs:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/CreateDataset/y.json
    params:
    - circles_CreateDataset
  circles_DecisionTreeClassifier:
    cmd: zntrack run src.Classifier --name circles_DecisionTreeClassifier
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/DecisionTreeClassifier/metrics.json
    - nodes/circles/DecisionTreeClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/circles/DecisionTreeClassifier/figure.png
    params:
    - circles_DecisionTreeClassifier
  circles_GaussianNB:
    cmd: zntrack run src.Classifier --name circles_GaussianNB
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/GaussianNB/metrics.json
    - nodes/circles/GaussianNB/node-meta.json:
        cache: true
    outs:
    - nodes/circles/GaussianNB/figure.png
    params:
    - circles_GaussianNB
  circles_GaussianProcessClassifier:
    cmd: zntrack run src.Classifier --name circles_GaussianProcessClassifier
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/GaussianProcessClassifier/metrics.json
    - nodes/circles/GaussianProcessClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/circles/GaussianProcessClassifier/figure.png
    params:
    - circles_GaussianProcessClassifier
  circles_KNeighborsClassifier:
    cmd: zntrack run src.Classifier --name circles_KNeighborsClassifier
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/KNeighborsClassifier/metrics.json
    - nodes/circles/KNeighborsClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/circles/KNeighborsClassifier/figure.png
    params:
    - circles_KNeighborsClassifier
  circles_Linear-SVM:
    cmd: zntrack run src.Classifier --name circles_Linear-SVM
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/Linear-SVM/metrics.json
    - nodes/circles/Linear-SVM/node-meta.json:
        cache: true
    outs:
    - nodes/circles/Linear-SVM/figure.png
    params:
    - circles_Linear-SVM
  circles_MLPClassifier:
    cmd: zntrack run src.Classifier --name circles_MLPClassifier
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/MLPClassifier/metrics.json
    - nodes/circles/MLPClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/circles/MLPClassifier/figure.png
    params:
    - circles_MLPClassifier
  circles_QuadraticDiscriminantAnalysis:
    cmd: zntrack run src.Classifier --name circles_QuadraticDiscriminantAnalysis
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/QuadraticDiscriminantAnalysis/metrics.json
    - nodes/circles/QuadraticDiscriminantAnalysis/node-meta.json:
        cache: true
    outs:
    - nodes/circles/QuadraticDiscriminantAnalysis/figure.png
    params:
    - circles_QuadraticDiscriminantAnalysis
  circles_RBF-SVM:
    cmd: zntrack run src.Classifier --name circles_RBF-SVM
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/RBF-SVM/metrics.json
    - nodes/circles/RBF-SVM/node-meta.json:
        cache: true
    outs:
    - nodes/circles/RBF-SVM/figure.png
    params:
    - circles_RBF-SVM
  circles_RandomForestClassifier:
    cmd: zntrack run src.Classifier --name circles_RandomForestClassifier
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    metrics:
    - nodes/circles/RandomForestClassifier/metrics.json
    - nodes/circles/RandomForestClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/circles/RandomForestClassifier/figure.png
    params:
    - circles_RandomForestClassifier
  circles_TrainTestSplit:
    cmd: zntrack run src.TrainTestSplit --name circles_TrainTestSplit
    deps:
    - nodes/circles/CreateDataset/x.json
    - nodes/circles/CreateDataset/y.json
    metrics:
    - nodes/circles/TrainTestSplit/node-meta.json:
        cache: true
    outs:
    - nodes/circles/TrainTestSplit/x_test.json
    - nodes/circles/TrainTestSplit/x_train.json
    - nodes/circles/TrainTestSplit/y_test.json
    - nodes/circles/TrainTestSplit/y_train.json
    params:
    - circles_TrainTestSplit
  linearly-separable_AdaBoostClassifier:
    cmd: zntrack run src.Classifier --name linearly-separable_AdaBoostClassifier
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/AdaBoostClassifier/metrics.json
    - nodes/linearly-separable/AdaBoostClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/AdaBoostClassifier/figure.png
    params:
    - linearly-separable_AdaBoostClassifier
  linearly-separable_CombineFigures:
    cmd: zntrack run src.CombineFigures --name linearly-separable_CombineFigures
    deps:
    - nodes/linearly-separable/AdaBoostClassifier/figure.png
    - nodes/linearly-separable/AdaBoostClassifier/metrics.json
    - nodes/linearly-separable/DecisionTreeClassifier/figure.png
    - nodes/linearly-separable/DecisionTreeClassifier/metrics.json
    - nodes/linearly-separable/GaussianNB/figure.png
    - nodes/linearly-separable/GaussianNB/metrics.json
    - nodes/linearly-separable/GaussianProcessClassifier/figure.png
    - nodes/linearly-separable/GaussianProcessClassifier/metrics.json
    - nodes/linearly-separable/KNeighborsClassifier/figure.png
    - nodes/linearly-separable/KNeighborsClassifier/metrics.json
    - nodes/linearly-separable/Linear-SVM/figure.png
    - nodes/linearly-separable/Linear-SVM/metrics.json
    - nodes/linearly-separable/MLPClassifier/figure.png
    - nodes/linearly-separable/MLPClassifier/metrics.json
    - nodes/linearly-separable/QuadraticDiscriminantAnalysis/figure.png
    - nodes/linearly-separable/QuadraticDiscriminantAnalysis/metrics.json
    - nodes/linearly-separable/RBF-SVM/figure.png
    - nodes/linearly-separable/RBF-SVM/metrics.json
    - nodes/linearly-separable/RandomForestClassifier/figure.png
    - nodes/linearly-separable/RandomForestClassifier/metrics.json
    metrics:
    - nodes/linearly-separable/CombineFigures/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/CombineFigures/combined_figure.png
  linearly-separable_CreateDataset:
    cmd: zntrack run src.CreateDataset --name linearly-separable_CreateDataset
    metrics:
    - nodes/linearly-separable/CreateDataset/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/CreateDataset/y.json
    params:
    - linearly-separable_CreateDataset
  linearly-separable_DecisionTreeClassifier:
    cmd: zntrack run src.Classifier --name linearly-separable_DecisionTreeClassifier
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/DecisionTreeClassifier/metrics.json
    - nodes/linearly-separable/DecisionTreeClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/DecisionTreeClassifier/figure.png
    params:
    - linearly-separable_DecisionTreeClassifier
  linearly-separable_GaussianNB:
    cmd: zntrack run src.Classifier --name linearly-separable_GaussianNB
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/GaussianNB/metrics.json
    - nodes/linearly-separable/GaussianNB/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/GaussianNB/figure.png
    params:
    - linearly-separable_GaussianNB
  linearly-separable_GaussianProcessClassifier:
    cmd: zntrack run src.Classifier --name linearly-separable_GaussianProcessClassifier
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/GaussianProcessClassifier/metrics.json
    - nodes/linearly-separable/GaussianProcessClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/GaussianProcessClassifier/figure.png
    params:
    - linearly-separable_GaussianProcessClassifier
  linearly-separable_KNeighborsClassifier:
    cmd: zntrack run src.Classifier --name linearly-separable_KNeighborsClassifier
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/KNeighborsClassifier/metrics.json
    - nodes/linearly-separable/KNeighborsClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/KNeighborsClassifier/figure.png
    params:
    - linearly-separable_KNeighborsClassifier
  linearly-separable_Linear-SVM:
    cmd: zntrack run src.Classifier --name linearly-separable_Linear-SVM
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/Linear-SVM/metrics.json
    - nodes/linearly-separable/Linear-SVM/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/Linear-SVM/figure.png
    params:
    - linearly-separable_Linear-SVM
  linearly-separable_MLPClassifier:
    cmd: zntrack run src.Classifier --name linearly-separable_MLPClassifier
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/MLPClassifier/metrics.json
    - nodes/linearly-separable/MLPClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/MLPClassifier/figure.png
    params:
    - linearly-separable_MLPClassifier
  linearly-separable_QuadraticDiscriminantAnalysis:
    cmd: zntrack run src.Classifier --name linearly-separable_QuadraticDiscriminantAnalysis
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/QuadraticDiscriminantAnalysis/metrics.json
    - nodes/linearly-separable/QuadraticDiscriminantAnalysis/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/QuadraticDiscriminantAnalysis/figure.png
    params:
    - linearly-separable_QuadraticDiscriminantAnalysis
  linearly-separable_RBF-SVM:
    cmd: zntrack run src.Classifier --name linearly-separable_RBF-SVM
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/RBF-SVM/metrics.json
    - nodes/linearly-separable/RBF-SVM/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/RBF-SVM/figure.png
    params:
    - linearly-separable_RBF-SVM
  linearly-separable_RandomForestClassifier:
    cmd: zntrack run src.Classifier --name linearly-separable_RandomForestClassifier
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    metrics:
    - nodes/linearly-separable/RandomForestClassifier/metrics.json
    - nodes/linearly-separable/RandomForestClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/RandomForestClassifier/figure.png
    params:
    - linearly-separable_RandomForestClassifier
  linearly-separable_TrainTestSplit:
    cmd: zntrack run src.TrainTestSplit --name linearly-separable_TrainTestSplit
    deps:
    - nodes/linearly-separable/CreateDataset/x.json
    - nodes/linearly-separable/CreateDataset/y.json
    metrics:
    - nodes/linearly-separable/TrainTestSplit/node-meta.json:
        cache: true
    outs:
    - nodes/linearly-separable/TrainTestSplit/x_test.json
    - nodes/linearly-separable/TrainTestSplit/x_train.json
    - nodes/linearly-separable/TrainTestSplit/y_test.json
    - nodes/linearly-separable/TrainTestSplit/y_train.json
    params:
    - linearly-separable_TrainTestSplit
  moons_AdaBoostClassifier:
    cmd: zntrack run src.Classifier --name moons_AdaBoostClassifier
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/AdaBoostClassifier/metrics.json
    - nodes/moons/AdaBoostClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/moons/AdaBoostClassifier/figure.png
    params:
    - moons_AdaBoostClassifier
  moons_CombineFigures:
    cmd: zntrack run src.CombineFigures --name moons_CombineFigures
    deps:
    - nodes/moons/AdaBoostClassifier/figure.png
    - nodes/moons/AdaBoostClassifier/metrics.json
    - nodes/moons/DecisionTreeClassifier/figure.png
    - nodes/moons/DecisionTreeClassifier/metrics.json
    - nodes/moons/GaussianNB/figure.png
    - nodes/moons/GaussianNB/metrics.json
    - nodes/moons/GaussianProcessClassifier/figure.png
    - nodes/moons/GaussianProcessClassifier/metrics.json
    - nodes/moons/KNeighborsClassifier/figure.png
    - nodes/moons/KNeighborsClassifier/metrics.json
    - nodes/moons/Linear-SVM/figure.png
    - nodes/moons/Linear-SVM/metrics.json
    - nodes/moons/MLPClassifier/figure.png
    - nodes/moons/MLPClassifier/metrics.json
    - nodes/moons/QuadraticDiscriminantAnalysis/figure.png
    - nodes/moons/QuadraticDiscriminantAnalysis/metrics.json
    - nodes/moons/RBF-SVM/figure.png
    - nodes/moons/RBF-SVM/metrics.json
    - nodes/moons/RandomForestClassifier/figure.png
    - nodes/moons/RandomForestClassifier/metrics.json
    metrics:
    - nodes/moons/CombineFigures/node-meta.json:
        cache: true
    outs:
    - nodes/moons/CombineFigures/combined_figure.png
  moons_CreateDataset:
    cmd: zntrack run src.CreateDataset --name moons_CreateDataset
    metrics:
    - nodes/moons/CreateDataset/node-meta.json:
        cache: true
    outs:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/CreateDataset/y.json
    params:
    - moons_CreateDataset
  moons_DecisionTreeClassifier:
    cmd: zntrack run src.Classifier --name moons_DecisionTreeClassifier
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/DecisionTreeClassifier/metrics.json
    - nodes/moons/DecisionTreeClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/moons/DecisionTreeClassifier/figure.png
    params:
    - moons_DecisionTreeClassifier
  moons_GaussianNB:
    cmd: zntrack run src.Classifier --name moons_GaussianNB
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/GaussianNB/metrics.json
    - nodes/moons/GaussianNB/node-meta.json:
        cache: true
    outs:
    - nodes/moons/GaussianNB/figure.png
    params:
    - moons_GaussianNB
  moons_GaussianProcessClassifier:
    cmd: zntrack run src.Classifier --name moons_GaussianProcessClassifier
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/GaussianProcessClassifier/metrics.json
    - nodes/moons/GaussianProcessClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/moons/GaussianProcessClassifier/figure.png
    params:
    - moons_GaussianProcessClassifier
  moons_KNeighborsClassifier:
    cmd: zntrack run src.Classifier --name moons_KNeighborsClassifier
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/KNeighborsClassifier/metrics.json
    - nodes/moons/KNeighborsClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/moons/KNeighborsClassifier/figure.png
    params:
    - moons_KNeighborsClassifier
  moons_Linear-SVM:
    cmd: zntrack run src.Classifier --name moons_Linear-SVM
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/Linear-SVM/metrics.json
    - nodes/moons/Linear-SVM/node-meta.json:
        cache: true
    outs:
    - nodes/moons/Linear-SVM/figure.png
    params:
    - moons_Linear-SVM
  moons_MLPClassifier:
    cmd: zntrack run src.Classifier --name moons_MLPClassifier
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/MLPClassifier/metrics.json
    - nodes/moons/MLPClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/moons/MLPClassifier/figure.png
    params:
    - moons_MLPClassifier
  moons_QuadraticDiscriminantAnalysis:
    cmd: zntrack run src.Classifier --name moons_QuadraticDiscriminantAnalysis
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/QuadraticDiscriminantAnalysis/metrics.json
    - nodes/moons/QuadraticDiscriminantAnalysis/node-meta.json:
        cache: true
    outs:
    - nodes/moons/QuadraticDiscriminantAnalysis/figure.png
    params:
    - moons_QuadraticDiscriminantAnalysis
  moons_RBF-SVM:
    cmd: zntrack run src.Classifier --name moons_RBF-SVM
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/RBF-SVM/metrics.json
    - nodes/moons/RBF-SVM/node-meta.json:
        cache: true
    outs:
    - nodes/moons/RBF-SVM/figure.png
    params:
    - moons_RBF-SVM
  moons_RandomForestClassifier:
    cmd: zntrack run src.Classifier --name moons_RandomForestClassifier
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    metrics:
    - nodes/moons/RandomForestClassifier/metrics.json
    - nodes/moons/RandomForestClassifier/node-meta.json:
        cache: true
    outs:
    - nodes/moons/RandomForestClassifier/figure.png
    params:
    - moons_RandomForestClassifier
  moons_TrainTestSplit:
    cmd: zntrack run src.TrainTestSplit --name moons_TrainTestSplit
    deps:
    - nodes/moons/CreateDataset/x.json
    - nodes/moons/CreateDataset/y.json
    metrics:
    - nodes/moons/TrainTestSplit/node-meta.json:
        cache: true
    outs:
    - nodes/moons/TrainTestSplit/x_test.json
    - nodes/moons/TrainTestSplit/x_train.json
    - nodes/moons/TrainTestSplit/y_test.json
    - nodes/moons/TrainTestSplit/y_train.json
    params:
    - moons_TrainTestSplit

params.yaml File

circles_AdaBoostClassifier:
  model:
    _cls: src.Model
    method: AdaBoostClassifier
    name: AdaBoostClassifier
    params:
      random_state: 42
circles_CreateDataset:
  method: make_circles
  params:
    factor: 0.5
    noise: 0.2
    random_state: 0
circles_DecisionTreeClassifier:
  model:
    _cls: src.Model
    method: DecisionTreeClassifier
    name: DecisionTreeClassifier
    params:
      max_depth: 5
      random_state: 42
circles_GaussianNB:
  model:
    _cls: src.Model
    method: GaussianNB
    name: GaussianNB
    params: {}
circles_GaussianProcessClassifier:
  model:
    _cls: src.Model
    method: GaussianProcessClassifier
    name: GaussianProcessClassifier
    params:
      random_state: 42
circles_KNeighborsClassifier:
  model:
    _cls: src.Model
    method: KNeighborsClassifier
    name: KNeighborsClassifier
    params:
      n_neighbors: 3
circles_Linear-SVM:
  model:
    _cls: src.Model
    method: SVC
    name: Linear-SVM
    params:
      C: 0.025
      kernel: linear
      random_state: 42
circles_MLPClassifier:
  model:
    _cls: src.Model
    method: MLPClassifier
    name: MLPClassifier
    params:
      alpha: 1
      max_iter: 1000
      random_state: 42
circles_QuadraticDiscriminantAnalysis:
  model:
    _cls: src.Model
    method: QuadraticDiscriminantAnalysis
    name: QuadraticDiscriminantAnalysis
    params: {}
circles_RBF-SVM:
  model:
    _cls: src.Model
    method: SVC
    name: RBF-SVM
    params:
      C: 1
      gamma: 2
      random_state: 42
circles_RandomForestClassifier:
  model:
    _cls: src.Model
    method: RandomForestClassifier
    name: RandomForestClassifier
    params:
      max_depth: 5
      max_features: 1
      n_estimators: 10
      random_state: 42
circles_TrainTestSplit:
  random_state: 42
  test_size: 0.4
linearly-separable_AdaBoostClassifier:
  model:
    _cls: src.Model
    method: AdaBoostClassifier
    name: AdaBoostClassifier
    params:
      random_state: 42
linearly-separable_CreateDataset:
  method: linearly_separable
  params:
    n_clusters_per_class: 1
    n_features: 2
    n_informative: 2
    n_redundant: 0
    random_state: 42
linearly-separable_DecisionTreeClassifier:
  model:
    _cls: src.Model
    method: DecisionTreeClassifier
    name: DecisionTreeClassifier
    params:
      max_depth: 5
      random_state: 42
linearly-separable_GaussianNB:
  model:
    _cls: src.Model
    method: GaussianNB
    name: GaussianNB
    params: {}
linearly-separable_GaussianProcessClassifier:
  model:
    _cls: src.Model
    method: GaussianProcessClassifier
    name: GaussianProcessClassifier
    params:
      random_state: 42
linearly-separable_KNeighborsClassifier:
  model:
    _cls: src.Model
    method: KNeighborsClassifier
    name: KNeighborsClassifier
    params:
      n_neighbors: 3
linearly-separable_Linear-SVM:
  model:
    _cls: src.Model
    method: SVC
    name: Linear-SVM
    params:
      C: 0.025
      kernel: linear
      random_state: 42
linearly-separable_MLPClassifier:
  model:
    _cls: src.Model
    method: MLPClassifier
    name: MLPClassifier
    params:
      alpha: 1
      max_iter: 1000
      random_state: 42
linearly-separable_QuadraticDiscriminantAnalysis:
  model:
    _cls: src.Model
    method: QuadraticDiscriminantAnalysis
    name: QuadraticDiscriminantAnalysis
    params: {}
linearly-separable_RBF-SVM:
  model:
    _cls: src.Model
    method: SVC
    name: RBF-SVM
    params:
      C: 1
      gamma: 2
      random_state: 42
linearly-separable_RandomForestClassifier:
  model:
    _cls: src.Model
    method: RandomForestClassifier
    name: RandomForestClassifier
    params:
      max_depth: 5
      max_features: 1
      n_estimators: 10
      random_state: 42
linearly-separable_TrainTestSplit:
  random_state: 42
  test_size: 0.4
moons_AdaBoostClassifier:
  model:
    _cls: src.Model
    method: AdaBoostClassifier
    name: AdaBoostClassifier
    params:
      random_state: 42
moons_CreateDataset:
  method: make_moons
  params:
    noise: 0.3
    random_state: 0
moons_DecisionTreeClassifier:
  model:
    _cls: src.Model
    method: DecisionTreeClassifier
    name: DecisionTreeClassifier
    params:
      max_depth: 5
      random_state: 42
moons_GaussianNB:
  model:
    _cls: src.Model
    method: GaussianNB
    name: GaussianNB
    params: {}
moons_GaussianProcessClassifier:
  model:
    _cls: src.Model
    method: GaussianProcessClassifier
    name: GaussianProcessClassifier
    params:
      random_state: 42
moons_KNeighborsClassifier:
  model:
    _cls: src.Model
    method: KNeighborsClassifier
    name: KNeighborsClassifier
    params:
      n_neighbors: 3
moons_Linear-SVM:
  model:
    _cls: src.Model
    method: SVC
    name: Linear-SVM
    params:
      C: 0.025
      kernel: linear
      random_state: 42
moons_MLPClassifier:
  model:
    _cls: src.Model
    method: MLPClassifier
    name: MLPClassifier
    params:
      alpha: 1
      max_iter: 1000
      random_state: 42
moons_QuadraticDiscriminantAnalysis:
  model:
    _cls: src.Model
    method: QuadraticDiscriminantAnalysis
    name: QuadraticDiscriminantAnalysis
    params: {}
moons_RBF-SVM:
  model:
    _cls: src.Model
    method: SVC
    name: RBF-SVM
    params:
      C: 1
      gamma: 2
      random_state: 42
moons_RandomForestClassifier:
  model:
    _cls: src.Model
    method: RandomForestClassifier
    name: RandomForestClassifier
    params:
      max_depth: 5
      max_features: 1
      n_estimators: 10
      random_state: 42
moons_TrainTestSplit:
  random_state: 42
  test_size: 0.4

zntrack.json File

{
    "moons_CreateDataset": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/CreateDataset"
        }
    },
    "moons_TrainTestSplit": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/TrainTestSplit"
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "y": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y",
                "item": null
            }
        }
    },
    "moons_KNeighborsClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/KNeighborsClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_Linear-SVM": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/Linear-SVM"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_RBF-SVM": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/RBF-SVM"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_GaussianProcessClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/GaussianProcessClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_DecisionTreeClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/DecisionTreeClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_RandomForestClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/RandomForestClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_MLPClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/MLPClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_AdaBoostClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/AdaBoostClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_GaussianNB": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/GaussianNB"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_QuadraticDiscriminantAnalysis": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/QuadraticDiscriminantAnalysis"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "moons_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "moons_CombineFigures": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/moons/CombineFigures"
        },
        "cfs": [
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_KNeighborsClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_Linear-SVM",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_RBF-SVM",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_GaussianProcessClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_DecisionTreeClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_RandomForestClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_MLPClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_AdaBoostClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_GaussianNB",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "moons_QuadraticDiscriminantAnalysis",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            }
        ],
        "combined_figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/combined_figure.png"
        }
    },
    "circles_CreateDataset": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/CreateDataset"
        }
    },
    "circles_TrainTestSplit": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/TrainTestSplit"
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "y": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y",
                "item": null
            }
        }
    },
    "circles_KNeighborsClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/KNeighborsClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_Linear-SVM": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/Linear-SVM"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_RBF-SVM": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/RBF-SVM"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_GaussianProcessClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/GaussianProcessClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_DecisionTreeClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/DecisionTreeClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_RandomForestClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/RandomForestClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_MLPClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/MLPClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_AdaBoostClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/AdaBoostClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_GaussianNB": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/GaussianNB"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_QuadraticDiscriminantAnalysis": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/QuadraticDiscriminantAnalysis"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "circles_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "circles_CombineFigures": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/circles/CombineFigures"
        },
        "cfs": [
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_KNeighborsClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_Linear-SVM",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_RBF-SVM",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_GaussianProcessClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_DecisionTreeClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_RandomForestClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_MLPClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_AdaBoostClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_GaussianNB",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "circles_QuadraticDiscriminantAnalysis",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            }
        ],
        "combined_figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/combined_figure.png"
        }
    },
    "linearly-separable_CreateDataset": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/CreateDataset"
        }
    },
    "linearly-separable_TrainTestSplit": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/TrainTestSplit"
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "y": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y",
                "item": null
            }
        }
    },
    "linearly-separable_KNeighborsClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/KNeighborsClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_Linear-SVM": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/Linear-SVM"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_RBF-SVM": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/RBF-SVM"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_GaussianProcessClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/GaussianProcessClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_DecisionTreeClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/DecisionTreeClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_RandomForestClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/RandomForestClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_MLPClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/MLPClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_AdaBoostClassifier": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/AdaBoostClassifier"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_GaussianNB": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/GaussianNB"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_QuadraticDiscriminantAnalysis": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/QuadraticDiscriminantAnalysis"
        },
        "model": {
            "_type": "@dataclasses.dataclass",
            "value": {
                "module": "src",
                "cls": "Model"
            }
        },
        "x": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_CreateDataset",
                        "cls": "CreateDataset",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x",
                "item": null
            }
        },
        "x_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_train",
                "item": null
            }
        },
        "y_train": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_train",
                "item": null
            }
        },
        "x_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "x_test",
                "item": null
            }
        },
        "y_test": {
            "_type": "znflow.Connection",
            "value": {
                "instance": {
                    "_type": "zntrack.Node",
                    "value": {
                        "module": "src",
                        "name": "linearly-separable_TrainTestSplit",
                        "cls": "TrainTestSplit",
                        "remote": null,
                        "rev": null
                    }
                },
                "attribute": "y_test",
                "item": null
            }
        },
        "figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/figure.png"
        }
    },
    "linearly-separable_CombineFigures": {
        "nwd": {
            "_type": "pathlib.Path",
            "value": "nodes/linearly-separable/CombineFigures"
        },
        "cfs": [
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_KNeighborsClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_Linear-SVM",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_RBF-SVM",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_GaussianProcessClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_DecisionTreeClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_RandomForestClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_MLPClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_AdaBoostClassifier",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_GaussianNB",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            },
            {
                "_type": "znflow.Connection",
                "value": {
                    "instance": {
                        "_type": "zntrack.Node",
                        "value": {
                            "module": "src",
                            "name": "linearly-separable_QuadraticDiscriminantAnalysis",
                            "cls": "Classifier",
                            "remote": null,
                            "rev": null
                        }
                    },
                    "attribute": null,
                    "item": null
                }
            }
        ],
        "combined_figure_path": {
            "_type": "pathlib.Path",
            "value": "$nwd$/combined_figure.png"
        }
    }
}