sdg-core-lib 0.1.0__py3-none-any.whl

sdg_core_lib/test/data_generator/models/keras/implementation/test_TabularVAE.py

@@ -0,0 +1,120 @@
+import numpy as np
+import pytest
+import os
+import shutil
+from sklearn.preprocessing import StandardScaler
+
+from sdg_core_lib.NumericDataset import NumericDataset
+from sdg_core_lib.data_generator.models.TrainingInfo import TrainingInfo
+from sdg_core_lib.data_generator.models.keras.VAE import VAE
+from sdg_core_lib.data_generator.models.keras.implementation.TabularVAE import (
+    TabularVAE,
+)
+
+
+@pytest.fixture()
+def data():
+    return NumericDataset(
+        [
+            {
+                "column_name": "A",
+                "column_type": "continuous",
+                "column_datatype": "float64",
+                "column_data": [1.0, 2.0, 3.0, 4.0, 5.0],
+            }
+        ]
+    )
+
+
+@pytest.fixture()
+def model_data_no_load():
+    return {
+        "metadata": {"example_key": "example_value"},
+        "model_name": "example_model",
+        "input_shape": "(13,)",
+        "load_path": None,
+        "epochs": 1,
+    }
+
+
+@pytest.fixture()
+def model_data_correct_train():
+    return {
+        "metadata": {"example_key": "example_value"},
+        "model_name": "example_model",
+        "input_shape": "(1,)",
+        "load_path": None,
+        "epochs": 1,
+    }
+
+
+def test_instantiate(model_data_no_load):
+    model = TabularVAE(**model_data_no_load)
+    assert model.model_name == model_data_no_load["model_name"]
+    assert model._load_path is None
+    assert model.input_shape == (13,)
+    assert model._epochs == 1
+    assert type(model._model) is VAE
+    assert model._scaler is None
+
+
+def test_preprocess(model_data_no_load, data):
+    model = TabularVAE(**model_data_no_load)
+    assert model._scaler is None
+    scaled_data = model._pre_process(data)
+    assert model._scaler is not None and type(model._scaler) is StandardScaler
+    assert type(scaled_data) is np.ndarray
+
+
+def test_self_description(model_data_no_load):
+    model = TabularVAE(**model_data_no_load)
+    self_description = model.self_describe()
+    assert self_description is not None
+    assert (
+        self_description["algorithm"]["name"]
+        == "sdg_core_lib.data_generator.models.keras.implementation.TabularVAE.TabularVAE"
+    )
+    assert self_description["algorithm"]["default_loss_function"] == "ELBO LOSS"
+    assert (
+        self_description["algorithm"]["description"]
+        == "A Variational Autoencoder for data generation"
+    )
+    assert self_description["datatypes"] == [
+        {"type": "float32", "is_categorical": False},
+        {"type": "int32", "is_categorical": False},
+        {"type": "int64", "is_categorical": False},
+    ]
+
+
+def test_save(model_data_no_load):
+    model = TabularVAE(**model_data_no_load)
+    model_path = "./test_model"
+    os.mkdir(model_path)
+    model.save(model_path)
+    assert os.path.isfile(os.path.join(model_path, "encoder.keras"))
+    assert os.path.isfile(os.path.join(model_path, "decoder.keras"))
+    assert os.path.isfile(os.path.join(model_path, "scaler.skops"))
+    shutil.rmtree(model_path)
+
+
+def test_train_wrong(model_data_no_load, data):
+    model = TabularVAE(**model_data_no_load)
+    with pytest.raises(ValueError) as exception_info:
+        model.train(data)
+    assert exception_info.type is ValueError
+
+
+def test_train_correct(model_data_correct_train, data):
+    model = TabularVAE(**model_data_correct_train)
+    assert model.training_info is None
+    assert model._scaler is None
+    model.train(data)
+    assert type(model._scaler) is StandardScaler
+    assert type(model.training_info) is TrainingInfo
+
+
+def test_infer(model_data_correct_train, data):
+    n_rows = 2
+    model = TabularVAE(**model_data_correct_train)
+    results = model.infer(n_rows)
+    assert results.shape == (n_rows, *model.input_shape)

sdg_core_lib/test/data_generator/models/keras/implementation/test_TimeSeriesVAE.py

@@ -0,0 +1,110 @@
+import numpy as np
+import pytest
+import os
+import shutil
+from sklearn.preprocessing import MinMaxScaler
+
+from sdg_core_lib.NumericDataset import NumericDataset
+from sdg_core_lib.data_generator.models.TrainingInfo import TrainingInfo
+from sdg_core_lib.data_generator.models.keras.VAE import VAE
+from sdg_core_lib.data_generator.models.keras.implementation.TimeSeriesVAE import (
+    TimeSeriesVAE,
+)
+
+
+@pytest.fixture()
+def model_data_correct_train():
+    return {
+        "metadata": {"example_key": "example_value"},
+        "model_name": "example_model",
+        "input_shape": "(2, 51)",
+        "load_path": None,
+        "epochs": 1,
+    }
+
+
+@pytest.fixture()
+def data():
+    return NumericDataset(
+        [
+            {
+                "column_name": "A",
+                "column_type": "time_series",
+                "column_datatype": "float64",
+                "column_data": np.linspace(-10, 10, 1020).reshape(-1, 51).tolist(),
+            },
+            {
+                "column_name": "B",
+                "column_type": "time_series",
+                "column_datatype": "float64",
+                "column_data": np.linspace(-10, 10, 1020).reshape(-1, 51).tolist(),
+            },
+        ]
+    )
+
+
+def test_instantiate(model_data_correct_train):
+    model = TimeSeriesVAE(**model_data_correct_train)
+    assert model.model_name == model_data_correct_train["model_name"]
+    assert model._load_path is None
+    assert model.input_shape == (2, 51)
+    assert model._epochs == 1
+    assert type(model._model) is VAE
+    assert model._scaler is None
+
+
+def test_preprocess(model_data_correct_train, data):
+    model = TimeSeriesVAE(**model_data_correct_train)
+    assert model._scaler is None
+    scaled_data = model._pre_process(data)
+    assert model._scaler is not None and type(model._scaler) is MinMaxScaler
+    assert type(scaled_data) is np.ndarray
+    assert scaled_data.shape == data.get_numpy_data(data.dataframe).shape
+    assert scaled_data.shape[1:] == model.input_shape
+
+
+def test_train_correct(model_data_correct_train, data):
+    model = TimeSeriesVAE(**model_data_correct_train)
+    assert model.training_info is None
+    assert model._scaler is None
+    model.train(data)
+    assert type(model._scaler) is MinMaxScaler
+    assert type(model.training_info) is TrainingInfo
+
+
+def test_save(model_data_correct_train):
+    model = TimeSeriesVAE(**model_data_correct_train)
+    model_path = "./test_model"
+    os.mkdir(model_path)
+    model.save(model_path)
+    assert os.path.isfile(os.path.join(model_path, "encoder.keras"))
+    assert os.path.isfile(os.path.join(model_path, "decoder.keras"))
+    assert os.path.isfile(os.path.join(model_path, "scaler.skops"))
+    shutil.rmtree(model_path)
+
+
+def test_self_description(model_data_correct_train):
+    model = TimeSeriesVAE(**model_data_correct_train)
+    self_description = model.self_describe()
+    assert self_description is not None
+    assert (
+        self_description["algorithm"]["name"]
+        == "sdg_core_lib.data_generator.models.keras.implementation.TimeSeriesVAE.TimeSeriesVAE"
+    )
+    assert self_description["algorithm"]["default_loss_function"] == "ELBO LOSS"
+    assert (
+        self_description["algorithm"]["description"]
+        == "A Beta-Variational Autoencoder for time series generation"
+    )
+    assert self_description["datatypes"] == [
+        {"type": "float32", "is_categorical": False},
+        {"type": "int32", "is_categorical": False},
+        {"type": "int64", "is_categorical": False},
+    ]
+
+
+def test_infer(model_data_correct_train, data):
+    n_rows = 2
+    model = TimeSeriesVAE(**model_data_correct_train)
+    results = model.infer(n_rows)
+    assert results.shape == (n_rows, *model.input_shape)

sdg_core_lib/test/data_generator/models/keras/test_KerasBaseVAE.py

@@ -0,0 +1,74 @@
+import pytest
+
+from sdg_core_lib.NumericDataset import NumericDataset
+from sdg_core_lib.data_generator.models.keras.KerasBaseVAE import KerasBaseVAE
+
+
+@pytest.fixture()
+def model():
+    return KerasBaseVAE(
+        metadata={},
+        model_name="Test-T_VAE",
+        input_shape="(13,)",
+        load_path=None,
+        latent_dim=2,
+    )
+
+
+@pytest.fixture()
+def correct_dataset():
+    data = [
+        {
+            "column_name": "A",
+            "column_type": "continuous",
+            "column_datatype": "float64",
+            "column_data": [1.0, 2.0, 3.0, 4.0, 5.0],
+        }
+    ]
+    return NumericDataset(data)
+
+
+def test_instantiate(model):
+    assert model._model is None
+    with pytest.raises(NotImplementedError) as exception_info:
+        model._instantiate()
+    assert exception_info.type is NotImplementedError
+
+
+def test_load_files(model):
+    wrong_filepath = ""
+    with pytest.raises(ValueError) as exception_info:
+        model._load_files(wrong_filepath)
+    assert exception_info.type is ValueError
+
+
+def test_set_hyperparameters(model):
+    hyperparams_wrong = {"wrong": 0.01, "test": 32, "foobar": 10}
+    model.set_hyperparameters(**hyperparams_wrong)
+    assert model._learning_rate is None
+    assert model._batch_size is None
+    assert model._epochs is None
+
+    hyperparams = {"learning_rate": 0.01, "batch_size": 32, "epochs": 10}
+    model.set_hyperparameters(**hyperparams)
+    assert model._learning_rate == 0.01
+    assert model._batch_size == 32
+    assert model._epochs == 10
+
+
+def test_train_not_initialized(model, correct_dataset):
+    with pytest.raises(NotImplementedError) as exception_info:
+        model.train(correct_dataset)
+    assert exception_info.type is NotImplementedError
+
+
+def test_train_wrong_data(model):
+    with pytest.raises(NotImplementedError) as exception_info:
+        model.train([1, 2, 3])
+    assert exception_info.type is NotImplementedError
+
+
+def test_infer(model):
+    with pytest.raises(AttributeError) as exception_info:
+        model.infer(2)
+    assert exception_info.type is AttributeError

sdg_core_lib/test/data_generator/models/test_ModelInfo.py

@@ -0,0 +1,27 @@
+import pytest
+
+from sdg_core_lib.data_generator.models.ModelInfo import ModelInfo, AllowedData
+
+
+@pytest.fixture()
+def model_info():
+    return ModelInfo(
+        default_loss_function="Test Loss Function",
+        description="This is a test model",
+        allowed_data=[AllowedData("int64", False), AllowedData("float32", False)],
+        name="Test",
+    )
+
+
+def test_get_data(model_info):
+    info = model_info.get_model_info()
+    assert info is not None
+    assert info["algorithm"] is not None
+    assert info["algorithm"]["default_loss_function"] == "Test Loss Function"
+    assert info["algorithm"]["description"] == "This is a test model"
+    assert info["algorithm"]["name"] == "Test"
+    assert len(info["datatypes"]) == 2
+    assert info["datatypes"][0]["type"] == "int64"
+    assert not info["datatypes"][0]["is_categorical"]
+    assert info["datatypes"][1]["type"] == "float32"
+    assert not info["datatypes"][1]["is_categorical"]

sdg_core_lib/test/data_generator/models/test_TrainingInfo.py

@@ -0,0 +1,30 @@
+import pytest
+from sdg_core_lib.data_generator.models.TrainingInfo import TrainingInfo
+
+
+@pytest.fixture
+def training_info():
+    return TrainingInfo(
+        loss_fn="mse",
+        train_samples=100,
+        train_loss=0.05,
+        validation_samples=20,
+        validation_loss=0.03,
+    )
+
+
+def test_training_info_to_dict(training_info):
+    assert training_info.to_dict() == {
+        "loss_function": "mse",
+        "train_samples": 100,
+        "train_loss": 0.05,
+        "val_samples": 20,
+        "val_loss": 0.03,
+    }
+
+
+def test_training_info_to_json(training_info):
+    assert (
+        training_info.to_json()
+        == '{"loss_function": "mse", "train_samples": 100, "train_loss": 0.05, "val_samples": 20, "val_loss": 0.03}'
+    )

sdg_core_lib/test/data_generator/models/test_UnspecializedModel.py

@@ -0,0 +1,32 @@
+import pytest
+
+from sdg_core_lib.data_generator.models.UnspecializedModel import UnspecializedModel
+
+
+@pytest.fixture(autouse=False)
+def unspecialized_model():
+    return UnspecializedModel(
+        metadata={}, model_name="Test-T_VAE", input_shape="(13,)", load_path=None
+    )
+
+
+def test_initialize():
+    with pytest.raises(TypeError) as exception_info:
+        _ = UnspecializedModel(
+            metadata={}, model_name="Test-T_VAE", input_shape="(13,)", load_path=None
+        )
+    assert exception_info.type is TypeError
+
+
+def test_parse_stringed_input_shape():
+    stringed_shape_1 = "(10,)"
+    stringed_shape_2 = "(10)"
+    stringed_shape_3 = "[10,]"
+    stringed_shape_4 = "{10,}"
+    stringed_shape_5 = "(13,10,)"
+
+    assert UnspecializedModel._parse_stringed_input_shape(stringed_shape_1) == (10,)
+    assert UnspecializedModel._parse_stringed_input_shape(stringed_shape_2) == (10,)
+    assert UnspecializedModel._parse_stringed_input_shape(stringed_shape_3) == (10,)
+    assert UnspecializedModel._parse_stringed_input_shape(stringed_shape_4) == (10,)
+    assert UnspecializedModel._parse_stringed_input_shape(stringed_shape_5) == (13, 10)

sdg_core_lib/test/data_generator/test_model_factory.py

@@ -0,0 +1,52 @@
+import pytest
+
+from sdg_core_lib.data_generator.model_factory import dynamic_import, model_factory
+from sdg_core_lib.data_generator.models.keras.implementation.TabularVAE import (
+    TabularVAE,
+)
+
+
+@pytest.fixture()
+def class_name():
+    return (
+        "sdg_core_lib.data_generator.models.keras.implementation.TabularVAE.TabularVAE"
+    )
+
+
+@pytest.fixture()
+def shapeless_model():
+    return {
+        "algorithm_name": "sdg_core_lib.data_generator.models.keras.implementation.TabularVAE.TabularVAE",
+        "model_name": "Test-T_VAE",
+    }
+
+
+@pytest.fixture()
+def shape_model():
+    return {
+        "algorithm_name": "sdg_core_lib.data_generator.models.keras.implementation.TabularVAE.TabularVAE",
+        "model_name": "Test-T_VAE",
+        "input_shape": "(13,)",
+    }
+
+
+def test_dynamic_import(class_name):
+    model_class = dynamic_import(class_name)
+    assert model_class is not None
+    assert model_class is TabularVAE
+
+
+def test_model_factory_empty(shapeless_model):
+    model = model_factory(shapeless_model, input_shape="(13,)")
+    assert type(model) is TabularVAE
+    assert model.input_shape == (13,)
+    assert model._model is not None
+    assert model.model_name is shapeless_model["model_name"]
+
+
+def test_model_factory_full(shape_model):
+    model = model_factory(shape_model)
+    assert type(model) is TabularVAE
+    assert model.input_shape == (13,)
+    assert model._model is not None
+    assert model.model_name is shape_model["model_name"]

sdg_core_lib/test/evaluate/test_Metrics.py

@@ -0,0 +1,62 @@
+from sdg_core_lib.evaluate.Metrics import (
+    Metric,
+    StatisticalMetric,
+    AdherenceMetric,
+    NoveltyMetric,
+    MetricReport,
+)
+
+
+def test_metric_init():
+    metric = Metric("title", "unit measure", 1.0)
+    assert metric.title == "title"
+    assert metric.unit_measure == "unit measure"
+    assert metric.value == 1.0
+
+
+def test_statistical_metric_init():
+    metric = StatisticalMetric("title", "unit measure", 1.0)
+    assert metric.title == "title"
+    assert metric.unit_measure == "unit measure"
+    assert metric.value == 1.0
+    assert metric.type == "statistical_metrics"
+
+
+def test_adherence_metric_init():
+    metric = AdherenceMetric("title", "unit measure", 1.0)
+    assert metric.title == "title"
+    assert metric.unit_measure == "unit measure"
+    assert metric.value == 1.0
+    assert metric.type == "adherence_metrics"
+
+
+def test_novelty_metric_init():
+    metric = NoveltyMetric("title", "unit measure", 1.0)
+    assert metric.title == "title"
+    assert metric.unit_measure == "unit measure"
+    assert metric.value == 1.0
+    assert metric.type == "novelty_metrics"
+
+
+def test_metric_report_init():
+    report = MetricReport()
+    assert report.report == {}
+
+
+def test_metric_report_add_metric():
+    report = MetricReport()
+    metric = StatisticalMetric("title", "unit measure", 1.0)
+    report.add_metric(metric)
+    assert len(report.report["statistical_metrics"]) == 1
+
+
+def test_metric_report_to_json():
+    report = MetricReport()
+    metric = StatisticalMetric("title", "unit measure", 1.0)
+    report.add_metric(metric)
+    json_report = report.to_json()
+    assert json_report["statistical_metrics"][0] == {
+        "title": "title",
+        "unit_measure": "unit measure",
+        "value": 1.0,
+    }

sdg_core_lib/test/evaluate/test_TabularComparisonEvaluator.py

@@ -0,0 +1,75 @@
+import pytest
+import pandas as pd
+
+from sdg_core_lib.evaluate.TabularComparison import TabularComparisonEvaluator
+
+
+@pytest.fixture()
+def real_data():
+    return pd.DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9], "d": [10, 11, 12]}
+    )
+
+
+@pytest.fixture()
+def synthetic_data():
+    return pd.DataFrame(
+        {"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9], "d": [10, 11, 12]}
+    )
+
+
+@pytest.fixture()
+def evaluator_correct(real_data, synthetic_data):
+    return TabularComparisonEvaluator(real_data, synthetic_data, ["a", "b"], ["c", "d"])
+
+
+def test_init(evaluator_correct, real_data, synthetic_data):
+    assert evaluator_correct._numerical_columns == ["a", "b"]
+    assert evaluator_correct._categorical_columns == ["c", "d"]
+    assert evaluator_correct._real_data.equals(real_data)
+    assert evaluator_correct._synthetic_data.equals(synthetic_data)
+
+
+def test_evaluate(evaluator_correct):
+    report = evaluator_correct.compute()
+    print(report)
+    assert "statistical_metrics" in report
+    assert "adherence_metrics" in report
+    assert "novelty_metrics" in report
+    statistical_metrics = report["statistical_metrics"]
+    adherence_metrics = report["adherence_metrics"]
+    novelty_metrics = report["novelty_metrics"]
+    statistical_metrics_titles = [metric["title"] for metric in statistical_metrics]
+    assert "Total Statistical Compliance" in statistical_metrics_titles
+    assert "Categorical Features Cramer's V" in statistical_metrics_titles
+    assert "Numerical Features Wasserstein Distance" in statistical_metrics_titles
+    assert (
+        len(adherence_metrics[0]["value"])
+        == len(evaluator_correct._categorical_columns)
+        and adherence_metrics[0]["title"]
+        == "Synthetic Categories Adherence to Real Categories"
+    )
+    assert (
+        len(adherence_metrics[1]["value"]) == len(evaluator_correct._numerical_columns)
+        and adherence_metrics[1]["title"]
+        == "Synthetic Numerical Min-Max Boundaries Adherence"
+    )
+    assert (
+        0 <= novelty_metrics[0]["value"] <= 100
+        and novelty_metrics[0]["title"] == "Unique Synthetic Data"
+    )
+    assert (
+        0 <= novelty_metrics[1]["value"] <= 100
+        and novelty_metrics[1]["title"] == "New Synthetic Data"
+    )
+
+
+def test_evaluate_cramer_v_distance(evaluator_correct):
+    cramer_v = evaluator_correct._evaluate_cramer_v_distance()
+    print(cramer_v)
+    assert 0 <= cramer_v <= 1
+
+
+def test_evaluate_wasserstein_distance(evaluator_correct):
+    wass_distance = evaluator_correct._evaluate_wasserstein_distance()
+    assert 0 <= wass_distance <= 1