tests

Author: R-Palazzo

sdgym/synthesizers/uniform.py

@@ -60,7 +60,7 @@ def _sample_from_synthesizer(self, synthesizer, n_samples):
         for name, column in transformed.items():
             kind = column.dtype.kind
             if kind == 'i':
-                values = np.random.randint(column.min(), column.max() + 1, size=n_samples)
+                values = np.random.randint(int(column.min()), int(column.max()) + 1, size=n_samples)
             elif kind in ['O', 'b']:
                 values = np.random.choice(column.unique(), size=n_samples)
             else:
@@ -71,7 +71,11 @@ def _sample_from_synthesizer(self, synthesizer, n_samples):
 
 
 class MultiTableUniformSynthesizer(BaselineSynthesizer):
-    """Synthesizer that uses UniformSynthesizer for multi-table data."""
+    """Multi-table Uniform Synthesizer.
+
+    This synthesizer trains a UniformSynthesizer on each table in the multi-table dataset.
+    It samples data from each table independently using the corresponding trained synthesizer.
+    """
 
     _MODALITY_FLAG = 'multi_table'
 
@@ -80,7 +84,7 @@ def __init__(self):
         self.num_rows_per_table = {}
 
     def _get_trained_synthesizer(self, data, metadata):
-        """This function should train single table UniformSynthesizers on each table in the data.
+        """Train a UniformSynthesizer for each table in the multi-table dataset.
 
         Args:
             data (dict):

sdgym/synthesizers/utils.py

@@ -1,26 +1,6 @@
 """Utility functions for synthesizers in SDGym."""
 
 from sdgym.synthesizers.base import BaselineSynthesizer
-from sdgym.synthesizers.sdv import (
-    _get_all_sdv_synthesizers,
-    _validate_modality,
-)
-
-
-def _get_sdgym_synthesizers(modality):
-    """Get SDGym synthesizers.
-
-    Returns:
-        list:
-            A list of available SDGym synthesizer names.
-    """
-    _validate_modality(modality)
-    synthesizers = BaselineSynthesizer._get_supported_synthesizers(modality)
-    sdv_synthesizer = _get_all_sdv_synthesizers()
-    sdgym_synthesizer = [
-        synthesizer for synthesizer in synthesizers if synthesizer not in sdv_synthesizer
-    ]
-    return sorted(sdgym_synthesizer)
 
 
 def get_available_single_table_synthesizers():

tests/integration/synthesizers/test_uniform.py

@@ -2,8 +2,10 @@
 
 import numpy as np
 import pandas as pd
+from pandas.api.types import is_numeric_dtype
+from sdv.datasets.demo import download_demo
 
-from sdgym.synthesizers.uniform import UniformSynthesizer
+from sdgym.synthesizers import MultiTableUniformSynthesizer, UniformSynthesizer
 
 
 def test_uniform_synthesizer():
@@ -69,3 +71,25 @@ def test_uniform_synthesizer():
 
     assert n_values_interval2 * 0.9 < n_values_interval1 < n_values_interval2 * 1.1
     assert n_values_interval3 * 0.9 < n_values_interval1 < n_values_interval3 * 1.1
+
+
+def test_multitable_uniform_synthesizer_end_to_end():
+    """Test the MultiTableUniformSynthesizer end to end."""
+    # Setup
+    data, metadata = download_demo(dataset_name='fake_hotels', modality='multi_table')
+    synthesizer = MultiTableUniformSynthesizer()
+
+    # Run
+    trained_synthesizer = synthesizer.get_trained_synthesizer(data, metadata.to_dict())
+    sampled_data = synthesizer.sample_from_synthesizer(trained_synthesizer, scale=2)
+
+    # Assert
+    for table_name, table_data in data.items():
+        sampled_table = sampled_data[table_name]
+        assert len(sampled_table) == len(table_data) * 2
+        for column_name in table_data.columns:
+            original_column = table_data[column_name]
+            sampled_column = sampled_table[column_name]
+            if is_numeric_dtype(original_column):
+                assert sampled_column.min() >= original_column.min()
+                assert sampled_column.max() <= original_column.max()

tests/integration/synthesizers/test_utils.py

@@ -28,7 +28,7 @@ def test_get_available_single_table_synthesizers():
 def test_get_available_multi_table_synthesizers():
     """Test the `get_available_multi_table_synthesizers` method"""
     # Setup
-    expected_synthesizers = ['HMASynthesizer']
+    expected_synthesizers = ['HMASynthesizer', 'MultiTableUniformSynthesizer']
 
     # Run
     synthesizers = get_available_multi_table_synthesizers()

tests/unit/synthesizers/test_base.py

@@ -9,15 +9,17 @@
 
 class TestBaselineSynthesizer:
     @patch('sdgym.synthesizers.utils.BaselineSynthesizer.get_subclasses')
-    def test__get_supported_synthesizers_mock(self, mock_get_subclasses):
+    @patch('sdgym.synthesizers.base._validate_modality')
+    def test__get_supported_synthesizers_mock(self, mock_validate_modality, mock_get_subclasses):
         """Test the `_get_supported_synthesizers` method with mocks."""
         # Setup
         mock_get_subclasses.return_value = {
-            'Variant:ColumnSynthesizer': Mock(_NATIVELY_SUPPORTED=False),
-            'Custom:MySynthesizer': Mock(_NATIVELY_SUPPORTED=False),
-            'ColumnSynthesizer': Mock(_NATIVELY_SUPPORTED=True),
-            'UniformSynthesizer': Mock(_NATIVELY_SUPPORTED=True),
-            'DataIdentity': Mock(_NATIVELY_SUPPORTED=True),
+            'Variant:Synthesizer': Mock(_NATIVELY_SUPPORTED=False, _MODALITY_FLAG='single_table'),
+            'Custom:MySynthesizer': Mock(_NATIVELY_SUPPORTED=False, _MODALITY_FLAG='single_table'),
+            'ColumnSynthesizer': Mock(_NATIVELY_SUPPORTED=True, _MODALITY_FLAG='single_table'),
+            'UniformSynthesizer': Mock(_NATIVELY_SUPPORTED=True, _MODALITY_FLAG='single_table'),
+            'MultiTableSynthesizer': Mock(_NATIVELY_SUPPORTED=True, _MODALITY_FLAG='multi_table'),
+            'DataIdentity': Mock(_NATIVELY_SUPPORTED=True, _MODALITY_FLAG='single_table'),
         }
         expected_synthesizers = [
             'ColumnSynthesizer',
@@ -26,9 +28,11 @@ def test__get_supported_synthesizers_mock(self, mock_get_subclasses):
         ]
 
         # Run
-        synthesizers = BaselineSynthesizer._get_supported_synthesizers()
+        synthesizers = BaselineSynthesizer._get_supported_synthesizers('single_table')
 
         # Assert
+        mock_validate_modality.assert_called_once_with('single_table')
+        mock_get_subclasses.assert_called_once_with(include_parents=True)
         assert synthesizers == expected_synthesizers
 
     def test_get_trained_synthesizer(self):

tests/unit/synthesizers/test_generate.py

@@ -55,7 +55,7 @@ def test_create_sdv_variant_synthesizer():
 
     # Assert
     assert out.__name__ == 'Variant:test_synth'
-    assert out.modality == 'single_table'
+    assert out._MODALITY_FLAG == 'single_table'
     assert out._MODEL_KWARGS == synthesizer_parameters
     assert out.SDV_NAME == synthesizer_class
     assert out._NATIVELY_SUPPORTED is False
@@ -85,7 +85,7 @@ def test_create_sdv_variant_synthesizer_multi_table():
 
     # Assert
     assert out.__name__ == 'Variant:test_synth'
-    assert out.modality == 'multi_table'
+    assert out._MODALITY_FLAG == 'multi_table'
     assert out._MODEL_KWARGS == synthesizer_parameters
     assert out.SDV_NAME == synthesizer_class
     assert out._NATIVELY_SUPPORTED is False

tests/unit/synthesizers/test_sdv.py

@@ -99,7 +99,7 @@ def test__get_trained_synthesizer(mock_logger):
     synthesizer = Mock()
     synthesizer.__class__.__name__ = 'GaussianCopulaClass'
     synthesizer._MODEL_KWARGS = {'enforce_min_max_values': False}
-    synthesizer.modality = 'single_table'
+    synthesizer._MODALITY_FLAG = 'single_table'
     synthesizer.SDV_NAME = 'GaussianCopulaSynthesizer'
 
     # Run
@@ -121,7 +121,7 @@ def test__sample_from_synthesizer(mock_logger):
     })
     base_synthesizer = Mock()
     base_synthesizer.__class__.__name__ = 'GaussianCopulaSynthesizer'
-    base_synthesizer.modality = 'single_table'
+    base_synthesizer._MODALITY_FLAG = 'single_table'
     synthesizer = Mock()
     synthesizer.sample.return_value = data
     n_samples = 3
@@ -187,7 +187,7 @@ def test__create_sdv_class_mock(mock_get_modality, mock_sys_modules):
 
     # Assert
     assert synt_class.__name__ == sdv_name
-    assert synt_class.modality == 'single_table'
+    assert synt_class._MODALITY_FLAG == 'single_table'
     assert synt_class._MODEL_KWARGS == {}
     assert synt_class.SDV_NAME == sdv_name
     assert issubclass(synt_class, BaselineSynthesizer)
@@ -212,7 +212,7 @@ def test__create_sdv_class():
 
     # Assert
     assert synthesizer_class.__name__ == sdv_name
-    assert synthesizer_class.modality == 'single_table'
+    assert synthesizer_class._MODALITY_FLAG == 'single_table'
     assert synthesizer_class._MODEL_KWARGS == {}
     assert issubclass(synthesizer_class, BaselineSynthesizer)