From ce3cf1167cf0b073c451c01f7ae3ae23c4a5b27e Mon Sep 17 00:00:00 2001 From: Emmanuel Jordy Menvouta <56538317+emmanueljordy@users.noreply.github.com> Date: Mon, 17 Feb 2025 14:13:43 +0100 Subject: [PATCH 1/4] add data processing class --- .pre-commit-config.yaml | 60 +++++ requirements.txt | 3 +- synthpop/method/GC.py | 423 ++++++++++++++++++++++++++++++ synthpop/method/helpers.py | 169 ++++++++++++ synthpop/method/test_method.ipynb | 0 synthpop/processor/data_processor | 137 ++++++++++ 6 files changed, 791 insertions(+), 1 deletion(-) create mode 100644 .pre-commit-config.yaml create mode 100644 synthpop/method/GC.py create mode 100644 synthpop/method/test_method.ipynb create mode 100644 synthpop/processor/data_processor diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..0249621 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,60 @@ +repos: + # 1. Code Formatter: Black (Ensures uniform formatting) + - repo: https://github.com/psf/black + rev: stable + hooks: + - id: black + + # 2. Code Formatter: isort (Sorts imports) + - repo: https://github.com/PyCQA/isort + rev: 5.12.0 + hooks: + - id: isort + + # 3. Linter: Flake8 (Finds style & syntax issues) + - repo: https://github.com/pycqa/flake8 + rev: 6.0.0 + hooks: + - id: flake8 + + # 4. Security: Bandit (Finds security vulnerabilities) + - repo: https://github.com/PyCQA/bandit + rev: stable + hooks: + - id: bandit + args: ["-r", "."] + + # 5. Security: detect-secrets (Prevents committing secrets) + - repo: https://github.com/Yelp/detect-secrets + rev: v1.3.0 + hooks: + - id: detect-secrets-hook + + # 6. Type Checker: mypy (Checks for type errors) + - repo: https://github.com/pre-commit/mirrors-mypy + rev: v1.0 + hooks: + - id: mypy + + # 7. Tests: Pytest (Runs test cases before commit) + - repo: local + hooks: + - id: pytest + name: Run Pytest + entry: pytest + language: system + types: [python] + + # 8. Dependency Check: pip-audit (Checks for vulnerable dependencies) + - repo: https://github.com/pypa/pip-audit + rev: v2.4.0 + hooks: + - id: pip-audit + + # 9. File Cleanup: Remove trailing whitespace + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.4.0 + hooks: + - id: trailing-whitespace + + diff --git a/requirements.txt b/requirements.txt index 3c8fd34..8fc59a0 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,5 @@ numpy>=1.20.0 pandas>=1.3.0 scikit-learn>=1.0.0 -pytest>=7.0.0 \ No newline at end of file +pytest>=7.0.0 +copulas>=0.1.0 diff --git a/synthpop/method/GC.py b/synthpop/method/GC.py new file mode 100644 index 0000000..ddaedf2 --- /dev/null +++ b/synthpop/method/GC.py @@ -0,0 +1,423 @@ +import inspect +import logging +import warnings +from copy import deepcopy +import numpy as np +import pandas as pd +import scipy +import copulas.univariate +from copulas import multivariate +from sklearn.preprocessing import OneHotEncoder +from synthpop.method.helpers import ( + validate_numerical_distributions, + warn_missing_numerical_distributions, + flatten_dict, + unflatten_dict, +) + +LOGGER = logging.getLogger(__name__) + + +class BaseSingleTableSynthesizer: + """Base class for single table synthesizers + Args: + metadata (dict): + dictionary containing for each column their name and the type + enforce_min_max_values (bool): + Specify whether or not to clip the data returned by ``reverse_transform`` of + the numerical transformer, ``FloatFormatter``, to the min and max values seen + during ``fit``. Defaults to ``True``. + enforce_rounding (bool): + Define rounding scheme for ``numerical`` columns. If ``True``, the data returned + by ``reverse_transform`` will be rounded as in the original data. Defaults to ``True``. + locales (list or str): + The default locale(s) to use for AnonymizedFaker transformers. + Defaults to ``['en_US']``. + """ + + def __init__( + self, + metadata, + enforce_min_max_values=True, + enforce_rounding=True, + locales=["en_US"], + ): + + self.metadata = metadata + self.enforce_min_max_values = enforce_min_max_values + self.enforce_rounding = enforce_rounding + self.locales = locales + + +class GaussianCopulaMethod(BaseSingleTableSynthesizer): + _DISTRIBUTIONS = { + "norm": copulas.univariate.GaussianUnivariate, + "beta": copulas.univariate.BetaUnivariate, + "truncnorm": copulas.univariate.TruncatedGaussian, + "gamma": copulas.univariate.GammaUnivariate, + "uniform": copulas.univariate.UniformUnivariate, + "gaussian_kde": copulas.univariate.GaussianKDE, + } + + @classmethod + def get_distribution_class(cls, distribution): + """Return the corresponding distribution class from ``copulas.univariate``. + + Args: + distribution (str): + A string representing a copulas univariate distribution. + + Returns: + copulas.univariate: + A copulas univariate class that corresponds to the distribution. + """ + if not isinstance(distribution, str) or distribution not in cls._DISTRIBUTIONS: + error_message = f"Invalid distribution specification '{distribution}'." + raise ValueError(error_message) + + return cls._DISTRIBUTIONS[distribution] + + def __init__( + self, + metadata, + enforce_min_max_values=True, + enforce_rounding=True, + locales=["en_US"], + numerical_distributions=None, + default_distribution=None, + ): + super().__init__(metadata, enforce_min_max_values, enforce_rounding, locales) + validate_numerical_distributions(numerical_distributions, self.metadata.columns) + + self.default_distribution = default_distribution or "beta" + self._default_distribution = self.get_distribution_class( + self.default_distribution + ) + + self._set_numerical_distributions(numerical_distributions) + self._num_rows = None + + def _set_numerical_distributions(self, numerical_distributions): + self.numerical_distributions = numerical_distributions or {} + self._numerical_distributions = { + field: self.get_distribution_class(distribution) + for field, distribution in self.numerical_distributions.items() + } + + def _fit(self, processed_data): + """Fit the model to the table. + + Args: + processed_data (pandas.DataFrame): + Data to be learned. + """ + warn_missing_numerical_distributions( + self.numerical_distributions, processed_data.columns + ) + self._num_rows = self._learn_num_rows(processed_data) + numerical_distributions = self._get_numerical_distributions(processed_data) + self._model = self._initialize_model(numerical_distributions) + self._fit_model(processed_data) + + def _learn_num_rows(self, processed_data): + return len(processed_data) + + def _get_numerical_distributions(self, processed_data): + numerical_distributions = deepcopy(self._numerical_distributions) + for column in processed_data.columns: + if column not in numerical_distributions: + numerical_distributions[column] = self._numerical_distributions.get( + column, self._default_distribution + ) + + return numerical_distributions + + def _initialize_model(self, numerical_distributions): + return multivariate.GaussianMultivariate(distribution=numerical_distributions) + + def _fit_model(self, processed_data): + with warnings.catch_warnings(): + warnings.filterwarnings("ignore", module="scipy") + self._model.fit(processed_data) + + def _warn_quality_and_performance(self, column_name_to_transformer): + """Raise warning if the quality/performance may be impacted. + + Args: + column_name_to_transformer (dict): + Dict mapping column names to transformers to be used for that column. + """ + for column, transformer in column_name_to_transformer.items(): + if isinstance(transformer, OneHotEncoder): + warnings.warn( + f"Using a OneHotEncoder transformer for column '{column}' " + "may slow down the preprocessing and modeling times." + ) + + def _sample(self, num_rows, conditions=None): + """Sample the indicated number of rows from the model. + + Args: + num_rows (int): + Amount of rows to sample. + conditions (dict): + If specified, this dictionary maps column names to the column + value. Then, this method generates ``num_rows`` samples, all of + which are conditioned on the given variables. + + Returns: + pandas.DataFrame: + Sampled data. + """ + return self._model.sample(num_rows, conditions=conditions) + + def _get_valid_columns_from_metadata(self, columns): + + valid_columns = [] + for column in columns: + for valid_column in self.metadata.columns: + if column.startswith(valid_column): + valid_columns.append(column) + break + + return valid_columns + + def get_learned_distributions(self): + """Get the marginal distributions used by the ``GaussianCopula``. + + Return a dictionary mapping the column names with the distribution name and the learned + parameters for those. + + Returns: + dict: + Dictionary containing the distributions used or detected for each column and the + learned parameters for those. + """ + if not self._fitted: + raise ValueError( + "Distributions have not been learned yet. Please fit your model first using 'fit'." + ) + + if not hasattr(self._model, "to_dict") or not self._model.to_dict(): + return {} + + parameters = self._model.to_dict() + columns = parameters["columns"] + univariates = deepcopy(parameters["univariates"]) + learned_distributions = {} + valid_columns = self._get_valid_columns_from_metadata(columns) + for column, learned_params in zip(columns, univariates): + if column in valid_columns: + distribution = self.numerical_distributions.get( + column, self.default_distribution + ) + learned_params.pop("type") + learned_distributions[column] = { + "distribution": distribution, + "learned_parameters": learned_params, + } + + return learned_distributions + + def _get_parameters(self): + """Get copula model parameters. + + Compute model ``correlation`` and ``distribution.std`` + before it returns the flatten dict. + + Returns: + dict: + Copula parameters. + + """ + for univariate in self._model.univariates: + univariate_type = type(univariate) + if univariate_type is copulas.univariate.Univariate: + univariate = univariate._instance + + params = self._model.to_dict() + + correlation = [] + for index, row in enumerate(params["correlation"][1:]): + correlation.append(row[: index + 1]) + + params["correlation"] = correlation + params["univariates"] = dict(zip(params.pop("columns"), params["univariates"])) + params["num_rows"] = self._num_rows + + return flatten_dict(params) + + @staticmethod + def _get_nearest_correlation_matrix(matrix): + """Find the nearest correlation matrix. + + If the given matrix is not Positive Semi-definite, which means + that any of its eigenvalues is negative, find the nearest PSD matrix + by setting the negative eigenvalues to 0 and rebuilding the matrix + from the same eigenvectors and the modified eigenvalues. + + After this, the matrix will be PSD but may not have 1s in the diagonal, + so the diagonal is replaced by 1s and then the PSD condition of the + matrix is validated again, repeating the process until the built matrix + contains 1s in all the diagonal and is PSD. + + After 10 iterations, the last step is skipped and the current PSD matrix + is returned even if it does not have all 1s in the diagonal. + + Insipired by: https://stackoverflow.com/a/63131250 + """ + eigenvalues, eigenvectors = scipy.linalg.eigh(matrix) + negative = eigenvalues < 0 + identity = np.identity(len(matrix)) + + iterations = 0 + while np.any(negative): + eigenvalues[negative] = 0 + matrix = eigenvectors.dot(np.diag(eigenvalues)).dot(eigenvectors.T) + if iterations >= 10: + break + + matrix = matrix - matrix * identity + identity + + max_value = np.abs(np.abs(matrix).max()) + if max_value > 1: + matrix /= max_value + + eigenvalues, eigenvectors = scipy.linalg.eigh(matrix) + negative = eigenvalues < 0 + iterations += 1 + + return matrix + + def _set_parameters(self, parameters, default_params=None): + """Set copula model parameters. + + Args: + params [dict]: + Copula flatten parameters. + default_params [list]: + Flattened list of parameters to fall back to if `params` are invalid. + + """ + if default_params is not None: + default_params = unflatten_dict(default_params) + else: + default_params = {} + + parameters = unflatten_dict(parameters) + if "num_rows" in parameters: + num_rows = parameters.pop("num_rows") + self._num_rows = 0 if pd.isna(num_rows) else max(0, int(round(num_rows))) + + if parameters: + parameters = self._rebuild_gaussian_copula(parameters, default_params) + self._model = multivariate.GaussianMultivariate.from_dict(parameters) + + def _rebuild_gaussian_copula(self, model_parameters, default_params=None): + """Rebuild the model params to recreate a Gaussian Multivariate instance. + + Args: + model_parameters (dict): + Sampled and reestructured model parameters. + default_parameters (dict): + Fall back parameters if sampled params are invalid. + + Returns: + dict: + Model parameters ready to recreate the model. + """ + if default_params is None: + default_params = {} + + columns = [] + univariates = [] + for column, univariate in model_parameters["univariates"].items(): + columns.append(column) + if column in self._numerical_distributions: + univariate_type = self._numerical_distributions[column] + else: + univariate_type = self.get_distribution_class(self.default_distribution) + + univariate["type"] = univariate_type + model = univariate_type.MODEL_CLASS + if hasattr(model, "_argcheck"): + to_check = { + parameter: univariate[parameter] + for parameter in inspect.signature( + model._argcheck + ).parameters.keys() + if parameter in univariate + } + if not model._argcheck(**to_check): + if column in default_params.get("univariates", []): + LOGGER.info( + f"Invalid parameters sampled for column '{column}', " + "using default parameters." + ) + univariate = default_params["univariates"][column] + univariate["type"] = univariate_type + else: + LOGGER.debug(f"Column '{column}' has invalid parameters.") + else: + LOGGER.debug( + f"Univariate for col '{column}' does not have _argcheck method." + ) + + if "scale" in univariate: + univariate["scale"] = max(0, univariate["scale"]) + + univariates.append(univariate) + + model_parameters["univariates"] = univariates + model_parameters["columns"] = columns + + correlation = model_parameters.get("correlation") + if correlation: + model_parameters["correlation"] = self._rebuild_correlation_matrix( + correlation + ) + else: + model_parameters["correlation"] = [[1.0]] + + return model_parameters + + @classmethod + def _rebuild_correlation_matrix(cls, triangular_correlation): + """Rebuild a valid correlation matrix from its lower half triangle. + + The input of this function is a list of lists of floats of size 1, 2, 3...n-1: + + [[c_{2,1}], [c_{3,1}, c_{3,2}], ..., [c_{n,1},...,c_{n,n-1}]] + + Corresponding to the values from the lower half of the original correlation matrix, + **excluding** the diagonal. + + The output is the complete correlation matrix reconstructed using the given values + and scaled to the :math:`[-1, 1]` range if necessary. + + Args: + triangle_correlation (list[list[float]]): + A list that contains lists of floats of size 1, 2, 3... up to ``n-1``, + where ``n`` is the size of the target correlation matrix. + + Returns: + numpy.ndarray: + rebuilt correlation matrix. + """ + zero = [0.0] + size = len(triangular_correlation) + 1 + left = np.zeros((size, size)) + right = np.zeros((size, size)) + for idx, values in enumerate(triangular_correlation): + values = values + zero * (size - idx - 1) + left[idx + 1, :] = values + right[:, idx + 1] = values + + correlation = left + right + max_value = np.abs(correlation).max() + if max_value > 1: + correlation /= max_value + + correlation += np.identity(size) + + return cls._get_nearest_correlation_matrix(correlation).tolist() diff --git a/synthpop/method/helpers.py b/synthpop/method/helpers.py index e4c1c93..39aaa2b 100644 --- a/synthpop/method/helpers.py +++ b/synthpop/method/helpers.py @@ -48,3 +48,172 @@ def smooth(dtype, y_synth, y_real_min, y_real_max): y_synth[indices] = y_synth[indices].astype(int) return y_synth + + +def validate_numerical_distributions(numerical_distributions, metadata_columns): + """Validate ``numerical_distributions``. + + Raise an error if it's not None or dict, or if its columns are not present in the metadata. + + Args: + numerical_distributions (dict): + Dictionary that maps field names from the table that is being modeled with + the distribution that needs to be used. + metadata_columns (list): + Columns present in the metadata. + """ + if numerical_distributions: + if not isinstance(numerical_distributions, dict): + raise TypeError('numerical_distributions can only be None or a dict instance.') + + invalid_columns = numerical_distributions.keys() - set(metadata_columns) + if invalid_columns: + raise SynthesizerInputError( + 'Invalid column names found in the numerical_distributions dictionary ' + f'{invalid_columns}. The column names you provide must be present ' + 'in the metadata.' + ) + +def warn_missing_numerical_distributions(numerical_distributions, processed_data_columns): + """Raise an `UserWarning` when numerical distribution columns don't exist anymore.""" + unseen_columns = numerical_distributions.keys() - set(processed_data_columns) + for column in unseen_columns: + warnings.warn( + f"Cannot use distribution '{numerical_distributions[column]}' for column " + f"'{column}' because the column is not statistically modeled.", + UserWarning, + ) + +def flatten_array(nested, prefix=''): + """Flatten an array as a dict. + + Args: + nested (list, numpy.array): + Iterable to flatten. + prefix (str): + Name to append to the array indices. Defaults to ``''``. + + Returns: + dict: + Flattened array. + """ + result = {} + for index in range(len(nested)): + prefix_key = '__'.join([prefix, str(index)]) if len(prefix) else str(index) + + value = nested[index] + if isinstance(value, (list, np.ndarray)): + result.update(flatten_array(value, prefix=prefix_key)) + + elif isinstance(value, dict): + result.update(flatten_dict(value, prefix=prefix_key)) + + else: + result[prefix_key] = value + + return result + + +def flatten_dict(nested, prefix=''): + """Flatten a dictionary. + + This method returns a flatten version of a dictionary, concatenating key names with + double underscores. + + Args: + nested (dict): + Original dictionary to flatten. + prefix (str): + Prefix to append to key name. Defaults to ``''``. + + Returns: + dict: + Flattened dictionary. + """ + result = {} + + for key, value in nested.items(): + prefix_key = '__'.join([prefix, str(key)]) if len(prefix) else key + + if key in IGNORED_DICT_KEYS and not isinstance(value, (dict, list)): + continue + + elif isinstance(value, dict): + result.update(flatten_dict(value, prefix_key)) + + elif isinstance(value, (np.ndarray, list)): + result.update(flatten_array(value, prefix_key)) + + else: + result[prefix_key] = value + + return result + +def unflatten_dict(flat): + """Transform a flattened dict into its original form. + + Args: + flat (dict): + Flattened dict. + + Returns: + dict: + Nested dict (if corresponds) + """ + unflattened = {} + + for key, value in sorted(flat.items(), key=_key_order): + if '__' in key: + key, subkey = key.split('__', 1) + subkey, name = subkey.rsplit('__', 1) + + if name.isdigit(): + column_index = int(name) + row_index = int(subkey) + + array = unflattened.setdefault(key, []) + + if len(array) == row_index: + row = [] + array.append(row) + elif len(array) == row_index + 1: + row = array[row_index] + else: + # This should never happen + raise ValueError('There was an error unflattening the extension.') + + if len(row) == column_index: + row.append(value) + else: + # This should never happen + raise ValueError('There was an error unflattening the extension.') + + else: + subdict = unflattened.setdefault(key, {}) + if subkey.isdigit() and key != 'univariates': + subkey = int(subkey) + + inner = subdict.setdefault(subkey, {}) + inner[name] = value + + else: + unflattened[key] = value + + return unflattened + + + +def extract_metadata(df: pd.DataFrame) -> dict: + """ + Extract metadata from a pandas DataFrame. + + Args: + df (pd.DataFrame): The input DataFrame. + + Returns: + dict: A dictionary where keys are column names and values are column types. + """ + return {col: str(df[col].dtype) for col in df.columns} + + + diff --git a/synthpop/method/test_method.ipynb b/synthpop/method/test_method.ipynb new file mode 100644 index 0000000..e69de29 diff --git a/synthpop/processor/data_processor b/synthpop/processor/data_processor new file mode 100644 index 0000000..73f3c3e --- /dev/null +++ b/synthpop/processor/data_processor @@ -0,0 +1,137 @@ +import pandas as pd +import numpy as np +import warnings +import logging +from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler, MinMaxScaler + +# Set up logging +LOGGER = logging.getLogger(__name__) + +class InvalidDataError(Exception): + """Custom exception for invalid data errors.""" + pass + +class DataProcessor: + """Preprocess and post-process data before and after synthetic data generation. + + Handles: + - Type conversions (categorical ↔ numerical). + - Missing value handling. + - Feature transformations for Gaussian Copula. + - Reverse transformations to restore original data types. + """ + + def __init__(self, metadata, enforce_rounding=True, enforce_min_max_values=True, model_kwargs=None, table_name=None, locales=['en_US']): + self.metadata = metadata + self.enforce_rounding = enforce_rounding + self.enforce_min_max_values = enforce_min_max_values + self.model_kwargs = model_kwargs or {} + self.table_name = table_name + self.locales = locales + self._fitted = False + self._prepared_for_fitting = False + self.encoders = {} # Stores encoders for categorical columns + self.scalers = {} # Stores scalers for numerical columns + self.original_columns = None # To restore column order + + def preprocess(self, data: pd.DataFrame) -> pd.DataFrame: + """Transform the raw data into numerical space.""" + if self._fitted: + warnings.warn( + "This model has already been fitted. To use new preprocessed data, " + "please refit the model using 'fit'." + ) + + self.validate(data) + self.original_columns = data.columns # Store original column order + processed_data = self._preprocess(data) + + return processed_data + + def _preprocess(self, data: pd.DataFrame) -> pd.DataFrame: + """Handles encoding, scaling, and missing values.""" + data = data.copy() + + for col, dtype in self.metadata.items(): + if dtype == "categorical": + # Use Label Encoding for small categories, OneHot for larger + encoder = LabelEncoder() if len(data[col].unique()) < 10 else OneHotEncoder(sparse=False, drop="first") + transformed_data = self._encode_categorical(data[col], encoder) + self.encoders[col] = encoder + data.drop(columns=[col], inplace=True) + data = pd.concat([data, transformed_data], axis=1) + + elif dtype == "numerical": + scaler = StandardScaler() + data[col] = self._handle_missing_values(data[col]) + data[col] = scaler.fit_transform(data[[col]]) + self.scalers[col] = scaler + + elif dtype == "boolean": + data[col] = data[col].astype(int) # Convert True/False to 1/0 + + elif dtype == "datetime": + data[col] = pd.to_datetime(data[col]).astype(int) // 10**9 # Convert to Unix timestamp + + return data + + def postprocess(self, synthetic_data: pd.DataFrame) -> pd.DataFrame: + """Transform numerical synthetic data back to its original format.""" + synthetic_data = synthetic_data.copy() + + for col, dtype in self.metadata.items(): + if dtype == "categorical" and col in self.encoders: + encoder = self.encoders[col] + synthetic_data[col] = self._decode_categorical(synthetic_data[col], encoder) + + elif dtype == "numerical" and col in self.scalers: + scaler = self.scalers[col] + synthetic_data[col] = scaler.inverse_transform(synthetic_data[[col]]) + + elif dtype == "boolean": + synthetic_data[col] = synthetic_data[col].round().astype(bool) + + elif dtype == "datetime": + synthetic_data[col] = pd.to_datetime(synthetic_data[col], unit='s') + + return synthetic_data[self.original_columns] # Restore original column order + + def validate(self, data: pd.DataFrame): + """Validate input data.""" + if not isinstance(data, pd.DataFrame): + raise ValueError("Input data must be a pandas DataFrame.") + + missing_columns = set(self.metadata.keys()) - set(data.columns) + if missing_columns: + raise InvalidDataError(f"Missing columns: {missing_columns}") + + primary_keys = [col for col, dtype in self.metadata.items() if dtype == "primary_key"] + for key in primary_keys: + if data[key].duplicated().any(): + raise InvalidDataError(f"Primary key '{key}' is not unique.") + + def _encode_categorical(self, series: pd.Series, encoder): + """Encode categorical columns.""" + if isinstance(encoder, LabelEncoder): + return pd.DataFrame(encoder.fit_transform(series), columns=[series.name]) + elif isinstance(encoder, OneHotEncoder): + encoded_array = encoder.fit_transform(series.values.reshape(-1, 1)) + encoded_df = pd.DataFrame(encoded_array, columns=encoder.get_feature_names_out([series.name])) + return encoded_df + + def _decode_categorical(self, series: pd.Series, encoder): + """Decode categorical columns.""" + if isinstance(encoder, LabelEncoder): + return encoder.inverse_transform(series.astype(int)) + elif isinstance(encoder, OneHotEncoder): + category_index = np.argmax(series.values, axis=1) + return encoder.categories_[0][category_index] + + def _handle_missing_values(self, series: pd.Series): + """Handle missing values based on column type.""" + if series.dtype in ["float64", "int64"]: + return series.fillna(series.median()) + elif series.dtype == "object": + return series.fillna(series.mode()[0]) + else: + return series.fillna(0) From 2faa8694d971fea59010dc040529539ccc32c467 Mon Sep 17 00:00:00 2001 From: Emmanuel Jordy Menvouta <56538317+emmanueljordy@users.noreply.github.com> Date: Fri, 21 Feb 2025 16:19:13 +0100 Subject: [PATCH 2/4] add missing data handler --- synthpop/processor/missing_data_handler.py | 95 ++++++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 synthpop/processor/missing_data_handler.py diff --git a/synthpop/processor/missing_data_handler.py b/synthpop/processor/missing_data_handler.py new file mode 100644 index 0000000..a1f5daa --- /dev/null +++ b/synthpop/processor/missing_data_handler.py @@ -0,0 +1,95 @@ +import numpy as np +import pandas as pd +import scipy.stats as stats +from sklearn.impute import SimpleImputer +from sklearn.linear_model import LogisticRegression +from sklearn.preprocessing import LabelEncoder +from fancyimpute import IterativeImputer # For MICE and EM +import warnings + +class MissingDataHandler: + """Detects missingness type (MCAR, MAR, MNAR) and applies automatic imputation.""" + + def __init__(self): + self.imputers = {} + + def detect_missingness(self, df: pd.DataFrame) -> dict: + """Detects missingness type for each column. + + Args: + df (pd.DataFrame): The input DataFrame. + + Returns: + dict: Dictionary mapping column names to detected missingness type. + """ + missingness = {} + + for col in df.columns: + missing_values = df[col].isna().sum() + if missing_values == 0: + continue # No missing values → Skip detection + + # 1️⃣ Little's MCAR Test + _, p_value = stats.chisquare(df[col].dropna().value_counts()) + if p_value > 0.05: + missingness[col] = "MCAR" + continue + + # 2️⃣ Logistic Regression (MAR Detection) + missing_mask = df[col].isna().astype(int) + observed_data = df.drop(columns=[col]).fillna(df.mean()) + + model = LogisticRegression() + model.fit(observed_data, missing_mask) + if model.score(observed_data, missing_mask) > 0.6: # Predictable missingness → MAR + missingness[col] = "MAR" + continue + + # 3️⃣ Distributional Check (MNAR Detection) + observed_values = df[col].dropna() + missing_rows = df[col].isna() + if missing_rows.sum() > 0: + missing_values = df.loc[missing_rows, df.columns != col].mean(axis=1) + _, p_value = stats.ks_2samp(observed_values, missing_values) + if p_value < 0.05: + missingness[col] = "MNAR" + continue + + missingness[col] = "MAR" # Default to MAR if uncertain + + return missingness + + def apply_imputation(self, df: pd.DataFrame, missingness: dict) -> pd.DataFrame: + """Automatically applies imputation based on missingness type. + + Args: + df (pd.DataFrame): Input data with missing values. + missingness (dict): Mapping of column names to missingness type. + + Returns: + pd.DataFrame: Data with imputed values. + """ + df = df.copy() + + for col, mtype in missingness.items(): + if df[col].dtype == "object": + # Categorical Data + if mtype == "MCAR": + df[col].fillna(df[col].mode()[0], inplace=True) # Mode Imputation + elif mtype == "MAR": + encoder = LabelEncoder() + df[col] = encoder.fit_transform(df[col].astype(str)) + df[col] = IterativeImputer().fit_transform(df[[col]]) # Classification-based + elif mtype == "MNAR": + df[col].fillna("Missing", inplace=True) # Add "Missing" Category + + else: + # Numerical Data + if mtype == "MCAR": + df[col] = SimpleImputer(strategy="mean").fit_transform(df[[col]]) + elif mtype == "MAR": + df[col] = IterativeImputer().fit_transform(df[[col]]) # Regression-based + elif mtype == "MNAR": + df[col] = IterativeImputer().fit_transform(df[[col]]) # EM Algorithm + + return df From 2f3c46565b337dd28978d20a87c5f8c6e1765e98 Mon Sep 17 00:00:00 2001 From: Emmanuel Jordy Menvouta <56538317+emmanueljordy@users.noreply.github.com> Date: Mon, 3 Mar 2025 15:41:35 +0100 Subject: [PATCH 3/4] Update repo by adding data handling logic and SDG methods Add: - pre/postprocessing - Gaussian Copula method -missing_data handler -example notebooks --- .venv/Scripts/Activate.ps1 | 502 ++++++++++++++++++ .venv/Scripts/activate | 70 +++ .venv/Scripts/activate.bat | 34 ++ .venv/Scripts/deactivate.bat | 22 + .venv/Scripts/f2py.exe | Bin 0 -> 108458 bytes .venv/Scripts/numpy-config.exe | Bin 0 -> 108458 bytes .venv/Scripts/pip.exe | Bin 0 -> 108465 bytes .venv/Scripts/pip3.12.exe | Bin 0 -> 108465 bytes .venv/Scripts/pip3.exe | Bin 0 -> 108465 bytes .venv/Scripts/py.test.exe | Bin 0 -> 108463 bytes .venv/Scripts/pytest.exe | Bin 0 -> 108463 bytes .venv/Scripts/python.exe | Bin 0 -> 270104 bytes .venv/Scripts/pythonw.exe | Bin 0 -> 258840 bytes .../01_missing_data_handler_example.ipynb | 127 +++++ .../02_data_processor_example.ipynb | 120 +++++ example_notebooks/03_gaussian_copula.ipynb | 123 +++++ example_notebooks/04_cart_method.ipynb | 122 +++++ example_notebooks/05_metrics.ipynb | 170 ++++++ pyproject.toml | 2 + setup.py | 1 + synthpop/__init__.py | 28 +- synthpop/constants.py | 2 + synthpop/method/GC.py | 465 +++++++--------- synthpop/method/__init__.py | 93 +--- synthpop/method/cart.py | 179 +++++-- synthpop/method/gaussian_copula.py | 106 ---- synthpop/method/helpers.py | 25 +- synthpop/method/test_method.ipynb | 0 synthpop/metrics/__init__.py | 29 + synthpop/metrics/diagnostic_report.py | 107 ++++ synthpop/metrics/efficacy_metrics.py | 101 ++++ synthpop/metrics/privacy_metrics.py | 86 +++ synthpop/metrics/single_columns_metrics.py | 253 +++++++++ synthpop/processor/__init__.py | 6 +- .../{data_processor => data_processor.py} | 12 +- synthpop/processor/missing_data_handler.py | 284 ++++++++-- synthpop/synthpop.py | 203 ------- synthpop/validator/__init__.py | 6 +- synthpop/validator/validator.py | 321 +---------- 39 files changed, 2510 insertions(+), 1089 deletions(-) create mode 100644 .venv/Scripts/Activate.ps1 create mode 100644 .venv/Scripts/activate create mode 100644 .venv/Scripts/activate.bat create mode 100644 .venv/Scripts/deactivate.bat create mode 100644 .venv/Scripts/f2py.exe create mode 100644 .venv/Scripts/numpy-config.exe create mode 100644 .venv/Scripts/pip.exe create mode 100644 .venv/Scripts/pip3.12.exe create mode 100644 .venv/Scripts/pip3.exe create mode 100644 .venv/Scripts/py.test.exe create mode 100644 .venv/Scripts/pytest.exe create mode 100644 .venv/Scripts/python.exe create mode 100644 .venv/Scripts/pythonw.exe create mode 100644 example_notebooks/01_missing_data_handler_example.ipynb create mode 100644 example_notebooks/02_data_processor_example.ipynb create mode 100644 example_notebooks/03_gaussian_copula.ipynb create mode 100644 example_notebooks/04_cart_method.ipynb create mode 100644 example_notebooks/05_metrics.ipynb create mode 100644 synthpop/constants.py delete mode 100644 synthpop/method/gaussian_copula.py delete mode 100644 synthpop/method/test_method.ipynb create mode 100644 synthpop/metrics/__init__.py create mode 100644 synthpop/metrics/diagnostic_report.py create mode 100644 synthpop/metrics/efficacy_metrics.py create mode 100644 synthpop/metrics/privacy_metrics.py create mode 100644 synthpop/metrics/single_columns_metrics.py rename synthpop/processor/{data_processor => data_processor.py} (93%) delete mode 100644 synthpop/synthpop.py diff --git a/.venv/Scripts/Activate.ps1 b/.venv/Scripts/Activate.ps1 new file mode 100644 index 0000000..b63e7b7 --- /dev/null +++ b/.venv/Scripts/Activate.ps1 @@ -0,0 +1,502 @@ +<# +.Synopsis +Activate a Python virtual environment for the current PowerShell session. + +.Description +Pushes the python executable for a virtual environment to the front of the +$Env:PATH environment variable and sets the prompt to signify that you are +in a Python virtual environment. Makes use of the command line switches as +well as the `pyvenv.cfg` file values present in the virtual environment. + +.Parameter VenvDir +Path to the directory that contains the virtual environment to activate. The +default value for this is the parent of the directory that the Activate.ps1 +script is located within. + +.Parameter Prompt +The prompt prefix to display when this virtual environment is activated. By +default, this prompt is the name of the virtual environment folder (VenvDir) +surrounded by parentheses and followed by a single space (ie. '(.venv) '). + +.Example +Activate.ps1 +Activates the Python virtual environment that contains the Activate.ps1 script. + +.Example +Activate.ps1 -Verbose +Activates the Python virtual environment that contains the Activate.ps1 script, +and shows extra information about the activation as it executes. + +.Example +Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv +Activates the Python virtual environment located in the specified location. + +.Example +Activate.ps1 -Prompt "MyPython" +Activates the Python virtual environment that contains the Activate.ps1 script, +and prefixes the current prompt with the specified string (surrounded in +parentheses) while the virtual environment is active. + +.Notes +On Windows, it may be required to enable this Activate.ps1 script by setting the +execution policy for the user. You can do this by issuing the following PowerShell +command: + +PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser + +For more information on Execution Policies: +https://go.microsoft.com/fwlink/?LinkID=135170 + +#> +Param( + [Parameter(Mandatory = $false)] + [String] + $VenvDir, + [Parameter(Mandatory = $false)] + [String] + $Prompt +) + +<# Function declarations --------------------------------------------------- #> + +<# +.Synopsis +Remove all shell session elements added by the Activate script, including the +addition of the virtual environment's Python executable from the beginning of +the PATH variable. + +.Parameter NonDestructive +If present, do not remove this function from the global namespace for the +session. + +#> +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + + # The prior prompt: + if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) { + Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt + Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT + } + + # The prior PYTHONHOME: + if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) { + Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME + Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME + } + + # The prior PATH: + if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) { + Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH + Remove-Item -Path Env:_OLD_VIRTUAL_PATH + } + + # Just remove the VIRTUAL_ENV altogether: + if (Test-Path -Path Env:VIRTUAL_ENV) { + Remove-Item -Path env:VIRTUAL_ENV + } + + # Just remove VIRTUAL_ENV_PROMPT altogether. + if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) { + Remove-Item -Path env:VIRTUAL_ENV_PROMPT + } + + # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether: + if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) { + Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force + } + + # Leave deactivate function in the global namespace if requested: + if (-not $NonDestructive) { + Remove-Item -Path function:deactivate + } +} + +<# +.Description +Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the +given folder, and returns them in a map. + +For each line in the pyvenv.cfg file, if that line can be parsed into exactly +two strings separated by `=` (with any amount of whitespace surrounding the =) +then it is considered a `key = value` line. The left hand string is the key, +the right hand is the value. + +If the value starts with a `'` or a `"` then the first and last character is +stripped from the value before being captured. + +.Parameter ConfigDir +Path to the directory that contains the `pyvenv.cfg` file. +#> +function Get-PyVenvConfig( + [String] + $ConfigDir +) { + Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg" + + # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue). + $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue + + # An empty map will be returned if no config file is found. + $pyvenvConfig = @{ } + + if ($pyvenvConfigPath) { + + Write-Verbose "File exists, parse `key = value` lines" + $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath + + $pyvenvConfigContent | ForEach-Object { + $keyval = $PSItem -split "\s*=\s*", 2 + if ($keyval[0] -and $keyval[1]) { + $val = $keyval[1] + + # Remove extraneous quotations around a string value. + if ("'""".Contains($val.Substring(0, 1))) { + $val = $val.Substring(1, $val.Length - 2) + } + + $pyvenvConfig[$keyval[0]] = $val + Write-Verbose "Adding Key: '$($keyval[0])'='$val'" + } + } + } + return $pyvenvConfig +} + + +<# Begin Activate script --------------------------------------------------- #> + +# Determine the containing directory of this script +$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition +$VenvExecDir = Get-Item -Path $VenvExecPath + +Write-Verbose "Activation script is located in path: '$VenvExecPath'" +Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)" +Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)" + +# Set values required in priority: CmdLine, ConfigFile, Default +# First, get the location of the virtual environment, it might not be +# VenvExecDir if specified on the command line. +if ($VenvDir) { + Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values" +} +else { + Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir." + $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/") + Write-Verbose "VenvDir=$VenvDir" +} + +# Next, read the `pyvenv.cfg` file to determine any required value such +# as `prompt`. +$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir + +# Next, set the prompt from the command line, or the config file, or +# just use the name of the virtual environment folder. +if ($Prompt) { + Write-Verbose "Prompt specified as argument, using '$Prompt'" +} +else { + Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value" + if ($pyvenvCfg -and $pyvenvCfg['prompt']) { + Write-Verbose " Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'" + $Prompt = $pyvenvCfg['prompt']; + } + else { + Write-Verbose " Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)" + Write-Verbose " Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'" + $Prompt = Split-Path -Path $venvDir -Leaf + } +} + +Write-Verbose "Prompt = '$Prompt'" +Write-Verbose "VenvDir='$VenvDir'" + +# Deactivate any currently active virtual environment, but leave the +# deactivate function in place. +deactivate -nondestructive + +# Now set the environment variable VIRTUAL_ENV, used by many tools to determine +# that there is an activated venv. +$env:VIRTUAL_ENV = $VenvDir + +if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) { + + Write-Verbose "Setting prompt to '$Prompt'" + + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT { "" } + Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT + New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt + + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) " + _OLD_VIRTUAL_PROMPT + } + $env:VIRTUAL_ENV_PROMPT = $Prompt +} + +# Clear PYTHONHOME +if (Test-Path -Path Env:PYTHONHOME) { + Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME + Remove-Item -Path Env:PYTHONHOME +} + +# Add the venv to the PATH +Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH +$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH" + +# SIG # Begin signature block +# MIIvIwYJKoZIhvcNAQcCoIIvFDCCLxACAQExDzANBglghkgBZQMEAgEFADB5Bgor +# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG +# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCBnL745ElCYk8vk +# dBtMuQhLeWJ3ZGfzKW4DHCYzAn+QB6CCE8MwggWQMIIDeKADAgECAhAFmxtXno4h +# MuI5B72nd3VcMA0GCSqGSIb3DQEBDAUAMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQK +# EwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNV +# BAMTGERpZ2lDZXJ0IFRydXN0ZWQgUm9vdCBHNDAeFw0xMzA4MDExMjAwMDBaFw0z +# ODAxMTUxMjAwMDBaMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJ +# bmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNVBAMTGERpZ2lDZXJ0 +# IFRydXN0ZWQgUm9vdCBHNDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB +# AL/mkHNo3rvkXUo8MCIwaTPswqclLskhPfKK2FnC4SmnPVirdprNrnsbhA3EMB/z +# G6Q4FutWxpdtHauyefLKEdLkX9YFPFIPUh/GnhWlfr6fqVcWWVVyr2iTcMKyunWZ +# anMylNEQRBAu34LzB4TmdDttceItDBvuINXJIB1jKS3O7F5OyJP4IWGbNOsFxl7s +# Wxq868nPzaw0QF+xembud8hIqGZXV59UWI4MK7dPpzDZVu7Ke13jrclPXuU15zHL +# 2pNe3I6PgNq2kZhAkHnDeMe2scS1ahg4AxCN2NQ3pC4FfYj1gj4QkXCrVYJBMtfb +# BHMqbpEBfCFM1LyuGwN1XXhm2ToxRJozQL8I11pJpMLmqaBn3aQnvKFPObURWBf3 +# JFxGj2T3wWmIdph2PVldQnaHiZdpekjw4KISG2aadMreSx7nDmOu5tTvkpI6nj3c +# AORFJYm2mkQZK37AlLTSYW3rM9nF30sEAMx9HJXDj/chsrIRt7t/8tWMcCxBYKqx +# YxhElRp2Yn72gLD76GSmM9GJB+G9t+ZDpBi4pncB4Q+UDCEdslQpJYls5Q5SUUd0 +# viastkF13nqsX40/ybzTQRESW+UQUOsxxcpyFiIJ33xMdT9j7CFfxCBRa2+xq4aL +# T8LWRV+dIPyhHsXAj6KxfgommfXkaS+YHS312amyHeUbAgMBAAGjQjBAMA8GA1Ud +# EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBTs1+OC0nFdZEzf +# Lmc/57qYrhwPTzANBgkqhkiG9w0BAQwFAAOCAgEAu2HZfalsvhfEkRvDoaIAjeNk +# aA9Wz3eucPn9mkqZucl4XAwMX+TmFClWCzZJXURj4K2clhhmGyMNPXnpbWvWVPjS +# PMFDQK4dUPVS/JA7u5iZaWvHwaeoaKQn3J35J64whbn2Z006Po9ZOSJTROvIXQPK +# 7VB6fWIhCoDIc2bRoAVgX+iltKevqPdtNZx8WorWojiZ83iL9E3SIAveBO6Mm0eB +# cg3AFDLvMFkuruBx8lbkapdvklBtlo1oepqyNhR6BvIkuQkRUNcIsbiJeoQjYUIp +# 5aPNoiBB19GcZNnqJqGLFNdMGbJQQXE9P01wI4YMStyB0swylIQNCAmXHE/A7msg +# dDDS4Dk0EIUhFQEI6FUy3nFJ2SgXUE3mvk3RdazQyvtBuEOlqtPDBURPLDab4vri +# RbgjU2wGb2dVf0a1TD9uKFp5JtKkqGKX0h7i7UqLvBv9R0oN32dmfrJbQdA75PQ7 +# 9ARj6e/CVABRoIoqyc54zNXqhwQYs86vSYiv85KZtrPmYQ/ShQDnUBrkG5WdGaG5 +# nLGbsQAe79APT0JsyQq87kP6OnGlyE0mpTX9iV28hWIdMtKgK1TtmlfB2/oQzxm3 +# i0objwG2J5VT6LaJbVu8aNQj6ItRolb58KaAoNYes7wPD1N1KarqE3fk3oyBIa0H +# EEcRrYc9B9F1vM/zZn4wggawMIIEmKADAgECAhAIrUCyYNKcTJ9ezam9k67ZMA0G +# CSqGSIb3DQEBDAUAMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQKEwxEaWdpQ2VydCBJ +# bmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNVBAMTGERpZ2lDZXJ0 +# IFRydXN0ZWQgUm9vdCBHNDAeFw0yMTA0MjkwMDAwMDBaFw0zNjA0MjgyMzU5NTla +# MGkxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwgSW5jLjFBMD8GA1UE +# AxM4RGlnaUNlcnQgVHJ1c3RlZCBHNCBDb2RlIFNpZ25pbmcgUlNBNDA5NiBTSEEz +# ODQgMjAyMSBDQTEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDVtC9C +# 0CiteLdd1TlZG7GIQvUzjOs9gZdwxbvEhSYwn6SOaNhc9es0JAfhS0/TeEP0F9ce +# 2vnS1WcaUk8OoVf8iJnBkcyBAz5NcCRks43iCH00fUyAVxJrQ5qZ8sU7H/Lvy0da +# E6ZMswEgJfMQ04uy+wjwiuCdCcBlp/qYgEk1hz1RGeiQIXhFLqGfLOEYwhrMxe6T +# SXBCMo/7xuoc82VokaJNTIIRSFJo3hC9FFdd6BgTZcV/sk+FLEikVoQ11vkunKoA +# FdE3/hoGlMJ8yOobMubKwvSnowMOdKWvObarYBLj6Na59zHh3K3kGKDYwSNHR7Oh +# D26jq22YBoMbt2pnLdK9RBqSEIGPsDsJ18ebMlrC/2pgVItJwZPt4bRc4G/rJvmM +# 1bL5OBDm6s6R9b7T+2+TYTRcvJNFKIM2KmYoX7BzzosmJQayg9Rc9hUZTO1i4F4z +# 8ujo7AqnsAMrkbI2eb73rQgedaZlzLvjSFDzd5Ea/ttQokbIYViY9XwCFjyDKK05 +# huzUtw1T0PhH5nUwjewwk3YUpltLXXRhTT8SkXbev1jLchApQfDVxW0mdmgRQRNY +# mtwmKwH0iU1Z23jPgUo+QEdfyYFQc4UQIyFZYIpkVMHMIRroOBl8ZhzNeDhFMJlP +# /2NPTLuqDQhTQXxYPUez+rbsjDIJAsxsPAxWEQIDAQABo4IBWTCCAVUwEgYDVR0T +# AQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUaDfg67Y7+F8Rhvv+YXsIiGX0TkIwHwYD +# VR0jBBgwFoAU7NfjgtJxXWRM3y5nP+e6mK4cD08wDgYDVR0PAQH/BAQDAgGGMBMG +# A1UdJQQMMAoGCCsGAQUFBwMDMHcGCCsGAQUFBwEBBGswaTAkBggrBgEFBQcwAYYY +# aHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEEGCCsGAQUFBzAChjVodHRwOi8vY2Fj +# ZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRUcnVzdGVkUm9vdEc0LmNydDBDBgNV +# HR8EPDA6MDigNqA0hjJodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGlnaUNlcnRU +# cnVzdGVkUm9vdEc0LmNybDAcBgNVHSAEFTATMAcGBWeBDAEDMAgGBmeBDAEEATAN +# BgkqhkiG9w0BAQwFAAOCAgEAOiNEPY0Idu6PvDqZ01bgAhql+Eg08yy25nRm95Ry +# sQDKr2wwJxMSnpBEn0v9nqN8JtU3vDpdSG2V1T9J9Ce7FoFFUP2cvbaF4HZ+N3HL +# IvdaqpDP9ZNq4+sg0dVQeYiaiorBtr2hSBh+3NiAGhEZGM1hmYFW9snjdufE5Btf +# Q/g+lP92OT2e1JnPSt0o618moZVYSNUa/tcnP/2Q0XaG3RywYFzzDaju4ImhvTnh +# OE7abrs2nfvlIVNaw8rpavGiPttDuDPITzgUkpn13c5UbdldAhQfQDN8A+KVssIh +# dXNSy0bYxDQcoqVLjc1vdjcshT8azibpGL6QB7BDf5WIIIJw8MzK7/0pNVwfiThV +# 9zeKiwmhywvpMRr/LhlcOXHhvpynCgbWJme3kuZOX956rEnPLqR0kq3bPKSchh/j +# wVYbKyP/j7XqiHtwa+aguv06P0WmxOgWkVKLQcBIhEuWTatEQOON8BUozu3xGFYH +# Ki8QxAwIZDwzj64ojDzLj4gLDb879M4ee47vtevLt/B3E+bnKD+sEq6lLyJsQfmC +# XBVmzGwOysWGw/YmMwwHS6DTBwJqakAwSEs0qFEgu60bhQjiWQ1tygVQK+pKHJ6l +# /aCnHwZ05/LWUpD9r4VIIflXO7ScA+2GRfS0YW6/aOImYIbqyK+p/pQd52MbOoZW +# eE4wggd3MIIFX6ADAgECAhAHHxQbizANJfMU6yMM0NHdMA0GCSqGSIb3DQEBCwUA +# MGkxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwgSW5jLjFBMD8GA1UE +# AxM4RGlnaUNlcnQgVHJ1c3RlZCBHNCBDb2RlIFNpZ25pbmcgUlNBNDA5NiBTSEEz +# ODQgMjAyMSBDQTEwHhcNMjIwMTE3MDAwMDAwWhcNMjUwMTE1MjM1OTU5WjB8MQsw +# CQYDVQQGEwJVUzEPMA0GA1UECBMGT3JlZ29uMRIwEAYDVQQHEwlCZWF2ZXJ0b24x +# IzAhBgNVBAoTGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMSMwIQYDVQQDExpQ +# eXRob24gU29mdHdhcmUgRm91bmRhdGlvbjCCAiIwDQYJKoZIhvcNAQEBBQADggIP +# ADCCAgoCggIBAKgc0BTT+iKbtK6f2mr9pNMUTcAJxKdsuOiSYgDFfwhjQy89koM7 +# uP+QV/gwx8MzEt3c9tLJvDccVWQ8H7mVsk/K+X+IufBLCgUi0GGAZUegEAeRlSXx +# xhYScr818ma8EvGIZdiSOhqjYc4KnfgfIS4RLtZSrDFG2tN16yS8skFa3IHyvWdb +# D9PvZ4iYNAS4pjYDRjT/9uzPZ4Pan+53xZIcDgjiTwOh8VGuppxcia6a7xCyKoOA +# GjvCyQsj5223v1/Ig7Dp9mGI+nh1E3IwmyTIIuVHyK6Lqu352diDY+iCMpk9Zanm +# SjmB+GMVs+H/gOiofjjtf6oz0ki3rb7sQ8fTnonIL9dyGTJ0ZFYKeb6BLA66d2GA +# LwxZhLe5WH4Np9HcyXHACkppsE6ynYjTOd7+jN1PRJahN1oERzTzEiV6nCO1M3U1 +# HbPTGyq52IMFSBM2/07WTJSbOeXjvYR7aUxK9/ZkJiacl2iZI7IWe7JKhHohqKuc +# eQNyOzxTakLcRkzynvIrk33R9YVqtB4L6wtFxhUjvDnQg16xot2KVPdfyPAWd81w +# tZADmrUtsZ9qG79x1hBdyOl4vUtVPECuyhCxaw+faVjumapPUnwo8ygflJJ74J+B +# Yxf6UuD7m8yzsfXWkdv52DjL74TxzuFTLHPyARWCSCAbzn3ZIly+qIqDAgMBAAGj +# ggIGMIICAjAfBgNVHSMEGDAWgBRoN+Drtjv4XxGG+/5hewiIZfROQjAdBgNVHQ4E +# FgQUt/1Teh2XDuUj2WW3siYWJgkZHA8wDgYDVR0PAQH/BAQDAgeAMBMGA1UdJQQM +# MAoGCCsGAQUFBwMDMIG1BgNVHR8Ega0wgaowU6BRoE+GTWh0dHA6Ly9jcmwzLmRp +# Z2ljZXJ0LmNvbS9EaWdpQ2VydFRydXN0ZWRHNENvZGVTaWduaW5nUlNBNDA5NlNI +# QTM4NDIwMjFDQTEuY3JsMFOgUaBPhk1odHRwOi8vY3JsNC5kaWdpY2VydC5jb20v +# RGlnaUNlcnRUcnVzdGVkRzRDb2RlU2lnbmluZ1JTQTQwOTZTSEEzODQyMDIxQ0Ex +# LmNybDA+BgNVHSAENzA1MDMGBmeBDAEEATApMCcGCCsGAQUFBwIBFhtodHRwOi8v +# d3d3LmRpZ2ljZXJ0LmNvbS9DUFMwgZQGCCsGAQUFBwEBBIGHMIGEMCQGCCsGAQUF +# BzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wXAYIKwYBBQUHMAKGUGh0dHA6 +# Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydFRydXN0ZWRHNENvZGVTaWdu +# aW5nUlNBNDA5NlNIQTM4NDIwMjFDQTEuY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZI +# hvcNAQELBQADggIBABxv4AeV/5ltkELHSC63fXAFYS5tadcWTiNc2rskrNLrfH1N +# s0vgSZFoQxYBFKI159E8oQQ1SKbTEubZ/B9kmHPhprHya08+VVzxC88pOEvz68nA +# 82oEM09584aILqYmj8Pj7h/kmZNzuEL7WiwFa/U1hX+XiWfLIJQsAHBla0i7QRF2 +# de8/VSF0XXFa2kBQ6aiTsiLyKPNbaNtbcucaUdn6vVUS5izWOXM95BSkFSKdE45O +# q3FForNJXjBvSCpwcP36WklaHL+aHu1upIhCTUkzTHMh8b86WmjRUqbrnvdyR2yd +# I5l1OqcMBjkpPpIV6wcc+KY/RH2xvVuuoHjlUjwq2bHiNoX+W1scCpnA8YTs2d50 +# jDHUgwUo+ciwpffH0Riq132NFmrH3r67VaN3TuBxjI8SIZM58WEDkbeoriDk3hxU +# 8ZWV7b8AW6oyVBGfM06UgkfMb58h+tJPrFx8VI/WLq1dTqMfZOm5cuclMnUHs2uq +# rRNtnV8UfidPBL4ZHkTcClQbCoz0UbLhkiDvIS00Dn+BBcxw/TKqVL4Oaz3bkMSs +# M46LciTeucHY9ExRVt3zy7i149sd+F4QozPqn7FrSVHXmem3r7bjyHTxOgqxRCVa +# 18Vtx7P/8bYSBeS+WHCKcliFCecspusCDSlnRUjZwyPdP0VHxaZg2unjHY3rMYIa +# tjCCGrICAQEwfTBpMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIElu +# Yy4xQTA/BgNVBAMTOERpZ2lDZXJ0IFRydXN0ZWQgRzQgQ29kZSBTaWduaW5nIFJT +# QTQwOTYgU0hBMzg0IDIwMjEgQ0ExAhAHHxQbizANJfMU6yMM0NHdMA0GCWCGSAFl +# AwQCAQUAoIHIMBkGCSqGSIb3DQEJAzEMBgorBgEEAYI3AgEEMBwGCisGAQQBgjcC +# AQsxDjAMBgorBgEEAYI3AgEVMC8GCSqGSIb3DQEJBDEiBCBnAZ6P7YvTwq0fbF62 +# o7E75R0LxsW5OtyYiFESQckLhjBcBgorBgEEAYI3AgEMMU4wTKBGgEQAQgB1AGkA +# bAB0ADoAIABSAGUAbABlAGEAcwBlAF8AdgAzAC4AMQAyAC4ANABfADIAMAAyADQA +# MAA2ADAANgAuADAAMaECgAAwDQYJKoZIhvcNAQEBBQAEggIAV29hYhi09QNyGtav +# HZIo33y/iqXsIa4o88S5gzBa7Nnkwra0QLitSjvRfVbcFvq54Id+VIn00di4Nde0 +# maAUKPGXtTQL48esG/F/TLDOWd/jb9qCYHyNZYpJjKdXqI8IbyG6Pl05IMSas7wX +# DHsK19ZEGuGrmKCAxh6JbFXADgeUbftg3i9UxpMnfSugZjjdKIdyVWlzUnpYkKuI +# fpafwvNHfIYzfxOeV9CWsdqe34D6fRrEs8ZDEZSQl+Mw9aGaT39vuryFE1iKOzj0 +# uqrX/wN/wwu8oLWNC7JWE8SDG3eD0QLy+x7zEnlPkWsRV9nGOgrP9Khge0LgL+jP +# Km8iDs7fSGEOB/7PPxAl8yshEULOZAhBhcsGeGs+kQrVzlqZ9WlrU1Z1cylpLWzX +# Kkvs2DXD+zrplhpiVv6Gnn3YMBr4BKf0mXESTX9/BzIwvxlkhpv/BT0OWwrDlgPM +# hNj8jA5r2/WSqCg15DYjJ0RlnCerC/ORhSbs7v/HjpmH3DhaICJF7tdyFSIFXgNV +# W0GyQJMulQDEPd2+o+PNyAPElvGC3SYTjVnRLPcJTGhAt+VuHfnMG4HNkmyeU+nk +# OAMShxEax6NLeRsjKqqABUgZb2g4FSmXzHy7HgQOPmCQMv8xH4m8u992YMLyxh5U +# gGRUOUiAhrHXNZ6wG6T52NGQppehghc/MIIXOwYKKwYBBAGCNwMDATGCFyswghcn +# BgkqhkiG9w0BBwKgghcYMIIXFAIBAzEPMA0GCWCGSAFlAwQCAQUAMHcGCyqGSIb3 +# DQEJEAEEoGgEZjBkAgEBBglghkgBhv1sBwEwMTANBglghkgBZQMEAgEFAAQg+eJt +# Pwl5Hz89rrpf2qbsjNAUNlBq9SGjVuw+Erci2HcCEDPjoeI//+uRP30fqUoeHIAY +# DzIwMjQwNjA2MTk1MDE0WqCCEwkwggbCMIIEqqADAgECAhAFRK/zlJ0IOaa/2z9f +# 5WEWMA0GCSqGSIb3DQEBCwUAMGMxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdp +# Q2VydCwgSW5jLjE7MDkGA1UEAxMyRGlnaUNlcnQgVHJ1c3RlZCBHNCBSU0E0MDk2 +# IFNIQTI1NiBUaW1lU3RhbXBpbmcgQ0EwHhcNMjMwNzE0MDAwMDAwWhcNMzQxMDEz +# MjM1OTU5WjBIMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIEluYy4x +# IDAeBgNVBAMTF0RpZ2lDZXJ0IFRpbWVzdGFtcCAyMDIzMIICIjANBgkqhkiG9w0B +# AQEFAAOCAg8AMIICCgKCAgEAo1NFhx2DjlusPlSzI+DPn9fl0uddoQ4J3C9Io5d6 +# OyqcZ9xiFVjBqZMRp82qsmrdECmKHmJjadNYnDVxvzqX65RQjxwg6seaOy+WZuNp +# 52n+W8PWKyAcwZeUtKVQgfLPywemMGjKg0La/H8JJJSkghraarrYO8pd3hkYhftF +# 6g1hbJ3+cV7EBpo88MUueQ8bZlLjyNY+X9pD04T10Mf2SC1eRXWWdf7dEKEbg8G4 +# 5lKVtUfXeCk5a+B4WZfjRCtK1ZXO7wgX6oJkTf8j48qG7rSkIWRw69XloNpjsy7p +# Be6q9iT1HbybHLK3X9/w7nZ9MZllR1WdSiQvrCuXvp/k/XtzPjLuUjT71Lvr1KAs +# NJvj3m5kGQc3AZEPHLVRzapMZoOIaGK7vEEbeBlt5NkP4FhB+9ixLOFRr7StFQYU +# 6mIIE9NpHnxkTZ0P387RXoyqq1AVybPKvNfEO2hEo6U7Qv1zfe7dCv95NBB+plwK +# WEwAPoVpdceDZNZ1zY8SdlalJPrXxGshuugfNJgvOuprAbD3+yqG7HtSOKmYCaFx +# smxxrz64b5bV4RAT/mFHCoz+8LbH1cfebCTwv0KCyqBxPZySkwS0aXAnDU+3tTbR +# yV8IpHCj7ArxES5k4MsiK8rxKBMhSVF+BmbTO77665E42FEHypS34lCh8zrTioPL +# QHsCAwEAAaOCAYswggGHMA4GA1UdDwEB/wQEAwIHgDAMBgNVHRMBAf8EAjAAMBYG +# A1UdJQEB/wQMMAoGCCsGAQUFBwMIMCAGA1UdIAQZMBcwCAYGZ4EMAQQCMAsGCWCG +# SAGG/WwHATAfBgNVHSMEGDAWgBS6FtltTYUvcyl2mi91jGogj57IbzAdBgNVHQ4E +# FgQUpbbvE+fvzdBkodVWqWUxo97V40kwWgYDVR0fBFMwUTBPoE2gS4ZJaHR0cDov +# L2NybDMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0VHJ1c3RlZEc0UlNBNDA5NlNIQTI1 +# NlRpbWVTdGFtcGluZ0NBLmNybDCBkAYIKwYBBQUHAQEEgYMwgYAwJAYIKwYBBQUH +# MAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBYBggrBgEFBQcwAoZMaHR0cDov +# L2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0VHJ1c3RlZEc0UlNBNDA5NlNI +# QTI1NlRpbWVTdGFtcGluZ0NBLmNydDANBgkqhkiG9w0BAQsFAAOCAgEAgRrW3qCp +# tZgXvHCNT4o8aJzYJf/LLOTN6l0ikuyMIgKpuM+AqNnn48XtJoKKcS8Y3U623mzX +# 4WCcK+3tPUiOuGu6fF29wmE3aEl3o+uQqhLXJ4Xzjh6S2sJAOJ9dyKAuJXglnSoF +# eoQpmLZXeY/bJlYrsPOnvTcM2Jh2T1a5UsK2nTipgedtQVyMadG5K8TGe8+c+nji +# kxp2oml101DkRBK+IA2eqUTQ+OVJdwhaIcW0z5iVGlS6ubzBaRm6zxbygzc0brBB +# Jt3eWpdPM43UjXd9dUWhpVgmagNF3tlQtVCMr1a9TMXhRsUo063nQwBw3syYnhmJ +# A+rUkTfvTVLzyWAhxFZH7doRS4wyw4jmWOK22z75X7BC1o/jF5HRqsBV44a/rCcs +# QdCaM0qoNtS5cpZ+l3k4SF/Kwtw9Mt911jZnWon49qfH5U81PAC9vpwqbHkB3NpE +# 5jreODsHXjlY9HxzMVWggBHLFAx+rrz+pOt5Zapo1iLKO+uagjVXKBbLafIymrLS +# 2Dq4sUaGa7oX/cR3bBVsrquvczroSUa31X/MtjjA2Owc9bahuEMs305MfR5ocMB3 +# CtQC4Fxguyj/OOVSWtasFyIjTvTs0xf7UGv/B3cfcZdEQcm4RtNsMnxYL2dHZeUb +# c7aZ+WssBkbvQR7w8F/g29mtkIBEr4AQQYowggauMIIElqADAgECAhAHNje3JFR8 +# 2Ees/ShmKl5bMA0GCSqGSIb3DQEBCwUAMGIxCzAJBgNVBAYTAlVTMRUwEwYDVQQK +# EwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xITAfBgNV +# BAMTGERpZ2lDZXJ0IFRydXN0ZWQgUm9vdCBHNDAeFw0yMjAzMjMwMDAwMDBaFw0z +# NzAzMjIyMzU5NTlaMGMxCzAJBgNVBAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwg +# SW5jLjE7MDkGA1UEAxMyRGlnaUNlcnQgVHJ1c3RlZCBHNCBSU0E0MDk2IFNIQTI1 +# NiBUaW1lU3RhbXBpbmcgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC +# AQDGhjUGSbPBPXJJUVXHJQPE8pE3qZdRodbSg9GeTKJtoLDMg/la9hGhRBVCX6SI +# 82j6ffOciQt/nR+eDzMfUBMLJnOWbfhXqAJ9/UO0hNoR8XOxs+4rgISKIhjf69o9 +# xBd/qxkrPkLcZ47qUT3w1lbU5ygt69OxtXXnHwZljZQp09nsad/ZkIdGAHvbREGJ +# 3HxqV3rwN3mfXazL6IRktFLydkf3YYMZ3V+0VAshaG43IbtArF+y3kp9zvU5Emfv +# DqVjbOSmxR3NNg1c1eYbqMFkdECnwHLFuk4fsbVYTXn+149zk6wsOeKlSNbwsDET +# qVcplicu9Yemj052FVUmcJgmf6AaRyBD40NjgHt1biclkJg6OBGz9vae5jtb7IHe +# IhTZgirHkr+g3uM+onP65x9abJTyUpURK1h0QCirc0PO30qhHGs4xSnzyqqWc0Jo +# n7ZGs506o9UD4L/wojzKQtwYSH8UNM/STKvvmz3+DrhkKvp1KCRB7UK/BZxmSVJQ +# 9FHzNklNiyDSLFc1eSuo80VgvCONWPfcYd6T/jnA+bIwpUzX6ZhKWD7TA4j+s4/T +# Xkt2ElGTyYwMO1uKIqjBJgj5FBASA31fI7tk42PgpuE+9sJ0sj8eCXbsq11GdeJg +# o1gJASgADoRU7s7pXcheMBK9Rp6103a50g5rmQzSM7TNsQIDAQABo4IBXTCCAVkw +# EgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUuhbZbU2FL3MpdpovdYxqII+e +# yG8wHwYDVR0jBBgwFoAU7NfjgtJxXWRM3y5nP+e6mK4cD08wDgYDVR0PAQH/BAQD +# AgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMIMHcGCCsGAQUFBwEBBGswaTAkBggrBgEF +# BQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEEGCCsGAQUFBzAChjVodHRw +# Oi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRUcnVzdGVkUm9vdEc0LmNy +# dDBDBgNVHR8EPDA6MDigNqA0hjJodHRwOi8vY3JsMy5kaWdpY2VydC5jb20vRGln +# aUNlcnRUcnVzdGVkUm9vdEc0LmNybDAgBgNVHSAEGTAXMAgGBmeBDAEEAjALBglg +# hkgBhv1sBwEwDQYJKoZIhvcNAQELBQADggIBAH1ZjsCTtm+YqUQiAX5m1tghQuGw +# GC4QTRPPMFPOvxj7x1Bd4ksp+3CKDaopafxpwc8dB+k+YMjYC+VcW9dth/qEICU0 +# MWfNthKWb8RQTGIdDAiCqBa9qVbPFXONASIlzpVpP0d3+3J0FNf/q0+KLHqrhc1D +# X+1gtqpPkWaeLJ7giqzl/Yy8ZCaHbJK9nXzQcAp876i8dU+6WvepELJd6f8oVInw +# 1YpxdmXazPByoyP6wCeCRK6ZJxurJB4mwbfeKuv2nrF5mYGjVoarCkXJ38SNoOeY +# +/umnXKvxMfBwWpx2cYTgAnEtp/Nh4cku0+jSbl3ZpHxcpzpSwJSpzd+k1OsOx0I +# SQ+UzTl63f8lY5knLD0/a6fxZsNBzU+2QJshIUDQtxMkzdwdeDrknq3lNHGS1yZr +# 5Dhzq6YBT70/O3itTK37xJV77QpfMzmHQXh6OOmc4d0j/R0o08f56PGYX/sr2H7y +# Rp11LB4nLCbbbxV7HhmLNriT1ObyF5lZynDwN7+YAN8gFk8n+2BnFqFmut1VwDop +# hrCYoCvtlUG3OtUVmDG0YgkPCr2B2RP+v6TR81fZvAT6gt4y3wSJ8ADNXcL50CN/ +# AAvkdgIm2fBldkKmKYcJRyvmfxqkhQ/8mJb2VVQrH4D6wPIOK+XW+6kvRBVK5xMO +# Hds3OBqhK/bt1nz8MIIFjTCCBHWgAwIBAgIQDpsYjvnQLefv21DiCEAYWjANBgkq +# hkiG9w0BAQwFADBlMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5j +# MRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBB +# c3N1cmVkIElEIFJvb3QgQ0EwHhcNMjIwODAxMDAwMDAwWhcNMzExMTA5MjM1OTU5 +# WjBiMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQL +# ExB3d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJv +# b3QgRzQwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1K +# PDAiMGkz7MKnJS7JIT3yithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2r +# snnyyhHS5F/WBTxSD1Ifxp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C +# 8weE5nQ7bXHiLQwb7iDVySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBf +# sXpm7nfISKhmV1efVFiODCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGY +# QJB5w3jHtrHEtWoYOAMQjdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8 +# rhsDdV14Ztk6MUSaM0C/CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaY +# dj1ZXUJ2h4mXaXpI8OCiEhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+ +# wJS00mFt6zPZxd9LBADMfRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw +# ++hkpjPRiQfhvbfmQ6QYuKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+N +# P8m800ERElvlEFDrMcXKchYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7F +# wI+isX4KJpn15GkvmB0t9dmpsh3lGwIDAQABo4IBOjCCATYwDwYDVR0TAQH/BAUw +# AwEB/zAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wHwYDVR0jBBgwFoAU +# Reuir/SSy4IxLVGLp6chnfNtyA8wDgYDVR0PAQH/BAQDAgGGMHkGCCsGAQUFBwEB +# BG0wazAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEMGCCsG +# AQUFBzAChjdodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1 +# cmVkSURSb290Q0EuY3J0MEUGA1UdHwQ+MDwwOqA4oDaGNGh0dHA6Ly9jcmwzLmRp +# Z2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcmwwEQYDVR0gBAow +# CDAGBgRVHSAAMA0GCSqGSIb3DQEBDAUAA4IBAQBwoL9DXFXnOF+go3QbPbYW1/e/ +# Vwe9mqyhhyzshV6pGrsi+IcaaVQi7aSId229GhT0E0p6Ly23OO/0/4C5+KH38nLe +# JLxSA8hO0Cre+i1Wz/n096wwepqLsl7Uz9FDRJtDIeuWcqFItJnLnU+nBgMTdydE +# 1Od/6Fmo8L8vC6bp8jQ87PcDx4eo0kxAGTVGamlUsLihVo7spNU96LHc/RzY9Hda +# XFSMb++hUD38dglohJ9vytsgjTVgHAIDyyCwrFigDkBjxZgiwbJZ9VVrzyerbHbO +# byMt9H5xaiNrIv8SuFQtJ37YOtnwtoeW/VvRXKwYw02fc7cBqZ9Xql4o4rmUMYID +# djCCA3ICAQEwdzBjMQswCQYDVQQGEwJVUzEXMBUGA1UEChMORGlnaUNlcnQsIElu +# Yy4xOzA5BgNVBAMTMkRpZ2lDZXJ0IFRydXN0ZWQgRzQgUlNBNDA5NiBTSEEyNTYg +# VGltZVN0YW1waW5nIENBAhAFRK/zlJ0IOaa/2z9f5WEWMA0GCWCGSAFlAwQCAQUA +# oIHRMBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcN +# MjQwNjA2MTk1MDE0WjArBgsqhkiG9w0BCRACDDEcMBowGDAWBBRm8CsywsLJD4Jd +# zqqKycZPGZzPQDAvBgkqhkiG9w0BCQQxIgQgUvswt0fWRoofHUAuTE0/8V9tLmHP +# zr/l2RTobZjBdqYwNwYLKoZIhvcNAQkQAi8xKDAmMCQwIgQg0vbkbe10IszR1EBX +# aEE2b4KK2lWarjMWr00amtQMeCgwDQYJKoZIhvcNAQEBBQAEggIAc7/uG/S8kf0i +# 2kaDQkE8NSfiXCYfN7z/2sgi6RNrkipvs/KTWfEKuMbhu9qWjjusZFgywn/IrZqw +# td4Js1kmaN+HJ02t/HXYUCr+KTJye4mDaBGvaXXHllCqsK7bhsJxJYE0uYiL03MP +# g64jyu9WdJD3N26MW/DkO6HTVhYzRzjafbAKbrr8KCvaFan1KZERzYwbA8XVjm88 +# HOodLCA9h+91Iqdc+uSz3Sg9/+Ns4zCp4BonvnsPYTlWTitiB5cpfPe/v4lBvCNu +# x0ha6whvKMdRLZJgXsiDXo2NwwB55kkWEBwD3a1RnBJQmyJxFEGpSXOrhmdcEWPg +# fjoHVIfowKBrIgINdWJbvIu+pLzQRMkVhuJzB32xpiZBIvbzkPETYQMOmKIu40I9 +# 5EAL0xNakPxYiT3nTkncn6woLOhiOXFm7crE+gO4IzDNauYuT9Vfe36K1CqtuYSy +# JesLIey9Z81OQqOo6n2/lW110MKMEV2PkPU7YW/bYO2uKsZ3OAjUWr63nMT+M2wk +# VdUAcqm0QdZsELY75Q3ekRxHje/B9ePP4Q4RMQGOZvmgqdtEeFhsmRwufR4fzfqx +# WMttmOHelTd8Sc0sfA9B+1dxtiC9GFn3de5/o+T2s/jQn6eNp2hvlCqGV0iFzSQp +# InPTBa9Na/+5UeXZ3NBWRvarfZ62TVM= +# SIG # End signature block diff --git a/.venv/Scripts/activate b/.venv/Scripts/activate new file mode 100644 index 0000000..cffeeaa --- /dev/null +++ b/.venv/Scripts/activate @@ -0,0 +1,70 @@ +# This file must be used with "source bin/activate" *from bash* +# You cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # Call hash to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + hash -r 2> /dev/null + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + unset VIRTUAL_ENV_PROMPT + if [ ! "${1:-}" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +# on Windows, a path can contain colons and backslashes and has to be converted: +if [ "${OSTYPE:-}" = "cygwin" ] || [ "${OSTYPE:-}" = "msys" ] ; then + # transform D:\path\to\venv to /d/path/to/venv on MSYS + # and to /cygdrive/d/path/to/venv on Cygwin + export VIRTUAL_ENV=$(cygpath "c:\Users\valen\OneDrive\Documents\Jordy Projects\AlgorithmAudit\python_synthpop\.venv") +else + # use the path as-is + export VIRTUAL_ENV="c:\Users\valen\OneDrive\Documents\Jordy Projects\AlgorithmAudit\python_synthpop\.venv" +fi + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/Scripts:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + PS1="(.venv) ${PS1:-}" + export PS1 + VIRTUAL_ENV_PROMPT="(.venv) " + export VIRTUAL_ENV_PROMPT +fi + +# Call hash to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +hash -r 2> /dev/null diff --git a/.venv/Scripts/activate.bat b/.venv/Scripts/activate.bat new file mode 100644 index 0000000..2d6b787 --- /dev/null +++ b/.venv/Scripts/activate.bat @@ -0,0 +1,34 @@ +@echo off + +rem This file is UTF-8 encoded, so we need to update the current code page while executing it +for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do ( + set _OLD_CODEPAGE=%%a +) +if defined _OLD_CODEPAGE ( + "%SystemRoot%\System32\chcp.com" 65001 > nul +) + +set VIRTUAL_ENV=c:\Users\valen\OneDrive\Documents\Jordy Projects\AlgorithmAudit\python_synthpop\.venv + +if not defined PROMPT set PROMPT=$P$G + +if defined _OLD_VIRTUAL_PROMPT set PROMPT=%_OLD_VIRTUAL_PROMPT% +if defined _OLD_VIRTUAL_PYTHONHOME set PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME% + +set _OLD_VIRTUAL_PROMPT=%PROMPT% +set PROMPT=(.venv) %PROMPT% + +if defined PYTHONHOME set _OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME% +set PYTHONHOME= + +if defined _OLD_VIRTUAL_PATH set PATH=%_OLD_VIRTUAL_PATH% +if not defined _OLD_VIRTUAL_PATH set _OLD_VIRTUAL_PATH=%PATH% + +set PATH=%VIRTUAL_ENV%\Scripts;%PATH% +set VIRTUAL_ENV_PROMPT=(.venv) + +:END +if defined _OLD_CODEPAGE ( + "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul + set _OLD_CODEPAGE= +) diff --git a/.venv/Scripts/deactivate.bat b/.venv/Scripts/deactivate.bat new file mode 100644 index 0000000..62a39a7 --- /dev/null +++ b/.venv/Scripts/deactivate.bat @@ -0,0 +1,22 @@ +@echo off + +if defined _OLD_VIRTUAL_PROMPT ( + set "PROMPT=%_OLD_VIRTUAL_PROMPT%" +) +set _OLD_VIRTUAL_PROMPT= + +if defined _OLD_VIRTUAL_PYTHONHOME ( + set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%" + set _OLD_VIRTUAL_PYTHONHOME= +) + +if defined _OLD_VIRTUAL_PATH ( + set "PATH=%_OLD_VIRTUAL_PATH%" +) + +set _OLD_VIRTUAL_PATH= + +set VIRTUAL_ENV= +set VIRTUAL_ENV_PROMPT= + +:END diff --git a/.venv/Scripts/f2py.exe b/.venv/Scripts/f2py.exe new file mode 100644 index 0000000000000000000000000000000000000000..dd6da593ec7c6e66273412e406907ddd7c57fd6a GIT binary patch literal 108458 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 P-*}-<*Ao@K(>4DGkQq#V literal 0 HcmV?d00001 diff --git a/.venv/Scripts/numpy-config.exe b/.venv/Scripts/numpy-config.exe new file mode 100644 index 0000000000000000000000000000000000000000..69d7106b2ad0bba5a67194ff82a71c4de63ead38 GIT binary patch literal 108458 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 Vnn4MDMLU1vg+5&`R5+t+{tpr1OQZk* literal 0 HcmV?d00001 diff --git a/.venv/Scripts/pip.exe b/.venv/Scripts/pip.exe new file mode 100644 index 0000000000000000000000000000000000000000..d2007fbfb86818c4af4eac79276da89f047e8652 GIT binary patch literal 108465 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
DV;hsUVL({ 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 LcHL3otgiV#``u4K literal 0 HcmV?d00001 diff --git a/.venv/Scripts/pytest.exe b/.venv/Scripts/pytest.exe new file mode 100644 index 0000000000000000000000000000000000000000..296a973907d2b923f56677025d48d14226195d76 GIT binary patch literal 108463 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
DV;hsUVL({ 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 LcHL3otgiV#``u4K literal 0 HcmV?d00001 diff --git a/.venv/Scripts/python.exe b/.venv/Scripts/python.exe new file mode 100644 index 0000000000000000000000000000000000000000..53121aefedc530b3cd70e9c10ed79327a69cf441 GIT binary patch literal 270104 zcmeFa4SZC^x%j`E?2-i%&SHrM#k$JUMnMgR)`W$+2X^(WY%~f8Dhf6bu~?0;3s?{W zn^ZQ3RchON`(kgYt-X5t;!CZ(Xf+|27hdGWs-U$++u9Qs+o&}JtnB~$%-Ou4Xzjh; z{`$Fp;gdac=FB|v%rnnC^UO2P%v4;p&XMbII9&W?G7iT^p7JlKe*eyo)8QC$+U6mS zM+WXZeWNqF^Ym%+Z&>83S$OmH3$OdKuj;y+Zn`<<`{F#`!uUibh;-{kqW=c$tK@_cpej*> zG@D|#)6ogOAN22>*u14NKGyt_G6f;2yD&w+e?Es}&N&O`UKhL0;W)9C55RP^@!ZU_ z-@hR2bB>+NF@Fc&)>Cjk305DA0O=afsj(BPI#O3h5$W!DU%KEq3l}Y{;*+8Yv~f%V z?vIa`Zr+VIlTgtJS~)yqvg|e_r2YlToelo~{$ZrtSI%-dns;RX8OdpWZ!{V57e$j% zzi;XlGmON+62m-Vq+OS8Fg@0=A2}RGVr$9lYp?Ew zB_NIDEWbx!1S95t!#r%6WH-!d{u+Iw@RyVa_~(t*kiS@317MQJXS6nxG7~koTaF() z9QBQw(QKHr{FRgvoZVZ7jpg(!X6RSgg>*zykNDRCC}Qptw9PlHB7p?L!N1^_l zk-U+j!2j-hrHoBdq-Hcp8Tz%euf68j%BcE8{UCTOk)&iJF>%As;YUamJ4c99CKQ`# zefOx;xA1PhLA9vatOzGXx`kw>B&4*Sf&gU*jwM2iklCcj0-f|tJ=F4Ta-86Bl~-PS#9_RR7}AQX3_*OYG?FDz8zsCz>kww=jhW zyhv-Kkkm-!Uuj(i$W78?t}{OjW%!+Zh$ z$rOI)S58N1yO2m=8Og!4s!&N}P}FP`t`&YV+cJg!Nm6rPePjImOyMsGC%Om3M;NJs z=cT~&Kxd<5>c>^)ZoUq`kgvn|N?W~;;Z%-(1Q-0gMsm5oXu6TQ(O+w%(2z?Kd zToF241Kx(Y2hc~Q;7!!DbZ=>Urto}l(l@OW#8cq|hPiL^K*0yHR2s0Vv_+=yuE(9i z{dI2ucGYr!r6kwte=mj9zo^x{Akh__juIP)4bFyRZqF1(Rqpr+kl9JSHq9fq^*k8t z&}KAB6V;S9YC}W*8Y3Crtql#=^0$t^_53}^Ut^~5@MBKLrY>p5!p{H=${MNZjn)^T z5Tq5zf1+BO<_hH71oEc0Rbt6!CvLMo*O&Os-o%wE@n2Qq9leQnTb{ne@Af7hDT&oU z105HWB2ze@JXs71dh7Pi-$*AUoY@-wsY9p)84VFw#MOjL8|6I+hmJ zQq%mEnZhe=phB>&UWieF2*65eRV(w?CeGS>)^Q~nz}F}%wJ5OKLPA*$!$Jom^-a69udK} z(|X|;tb=6w5vW7JE=MmaKwh%Xe5OKN%wE>6A~5dBC&Pku*kE5w

Y`T`{`vgv2kKpi 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 C;tFX1 literal 0 HcmV?d00001 diff --git a/.venv/Scripts/pythonw.exe b/.venv/Scripts/pythonw.exe new file mode 100644 index 0000000000000000000000000000000000000000..a09f6e9d7f2982d1ce6f3d247747fedfaf111a91 GIT binary patch literal 258840 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 z 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 z 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 z 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

=1.20.0", "pandas>=1.3.0", "scikit-learn>=1.0.0", + "copulas>=0.1.0", + ] readme = "README.md" license = {file = "LICENSE"} diff --git a/setup.py b/setup.py index 76a7d88..9b3ab5d 100644 --- a/setup.py +++ b/setup.py @@ -28,6 +28,7 @@ "numpy>=1.20.0", "pandas>=1.3.0", "scikit-learn>=1.0.0", + "copulas>=0.1.0", ], extras_require={ "dev": [ diff --git a/synthpop/__init__.py b/synthpop/__init__.py index 8e76743..69edef5 100644 --- a/synthpop/__init__.py +++ b/synthpop/__init__.py @@ -1,5 +1,25 @@ -NUM_COLS_DTYPES = ['int', 'float', 'datetime'] -CAT_COLS_DTYPES = ['category', 'bool'] +from .method import CARTMethod, GaussianCopulaMethod, proper, smooth +from .processor import DataProcessor, MissingDataHandler +from .validator import Validator +from .constants import NUM_COLS_DTYPES, CAT_COLS_DTYPES +from .metrics import MetricsReport, EfficacyMetrics, DisclosureProtection +# from .metrics import , compute_TSComplement # if needed + + +__all__ = [ + "CARTMethod", + "GaussianCopulaMethod", + "proper", + "smooth", + "DataProcessor", + "MissingDataHandler", + "Validator", + "MetricsReport", + "EfficacyMetrics", + "DisclosureProtection", + "NUM_COLS_DTYPES", + "CAT_COLS_DTYPES", + # "compute_TSComplement", +] + -from synthpop.synthpop import Synthpop -print('yes') \ No newline at end of file diff --git a/synthpop/constants.py b/synthpop/constants.py new file mode 100644 index 0000000..bfcb761 --- /dev/null +++ b/synthpop/constants.py @@ -0,0 +1,2 @@ +NUM_COLS_DTYPES = ['int', 'float', 'datetime'] +CAT_COLS_DTYPES = ['category', 'bool'] \ No newline at end of file diff --git a/synthpop/method/GC.py b/synthpop/method/GC.py index ddaedf2..5f902a4 100644 --- a/synthpop/method/GC.py +++ b/synthpop/method/GC.py @@ -2,6 +2,8 @@ import logging import warnings from copy import deepcopy +from typing import Any, Dict, List, Optional, Union + import numpy as np import pandas as pd import scipy @@ -17,40 +19,35 @@ LOGGER = logging.getLogger(__name__) - class BaseSingleTableSynthesizer: - """Base class for single table synthesizers + """ + Base class for single table synthesizers. + Args: - metadata (dict): - dictionary containing for each column their name and the type - enforce_min_max_values (bool): - Specify whether or not to clip the data returned by ``reverse_transform`` of - the numerical transformer, ``FloatFormatter``, to the min and max values seen - during ``fit``. Defaults to ``True``. - enforce_rounding (bool): - Define rounding scheme for ``numerical`` columns. If ``True``, the data returned - by ``reverse_transform`` will be rounded as in the original data. Defaults to ``True``. - locales (list or str): - The default locale(s) to use for AnonymizedFaker transformers. - Defaults to ``['en_US']``. + metadata (dict): Dictionary mapping column names to their types. + enforce_min_max_values (bool): Whether to clip reversed numerical values to the observed min/max. Defaults to True. + enforce_rounding (bool): Whether to round numerical columns during reverse transformation. Defaults to True. + locales (Union[List[str], str]): Default locale(s) to use. Defaults to "en_US". """ - def __init__( self, - metadata, - enforce_min_max_values=True, - enforce_rounding=True, - locales=["en_US"], - ): - + metadata: Dict[str, str], + enforce_min_max_values: bool = True, + enforce_rounding: bool = True, + locales: Union[List[str], str] = "en_US", + ) -> None: self.metadata = metadata self.enforce_min_max_values = enforce_min_max_values self.enforce_rounding = enforce_rounding - self.locales = locales + if isinstance(locales, str): + self.locales = [locales] + else: + self.locales = locales class GaussianCopulaMethod(BaseSingleTableSynthesizer): - _DISTRIBUTIONS = { + # Mapping of distribution name (lowercase) to copulas univariate classes. + _DISTRIBUTIONS: Dict[str, Any] = { "norm": copulas.univariate.GaussianUnivariate, "beta": copulas.univariate.BetaUnivariate, "truncnorm": copulas.univariate.TruncatedGaussian, @@ -58,366 +55,314 @@ class GaussianCopulaMethod(BaseSingleTableSynthesizer): "uniform": copulas.univariate.UniformUnivariate, "gaussian_kde": copulas.univariate.GaussianKDE, } + # Maximum iterations for correlation matrix adjustment + _MAX_CORR_ITERATIONS: int = 10 @classmethod - def get_distribution_class(cls, distribution): - """Return the corresponding distribution class from ``copulas.univariate``. + def get_distribution_class(cls, distribution: str) -> Any: + """ + Return the corresponding distribution class from copulas.univariate. Args: - distribution (str): - A string representing a copulas univariate distribution. + distribution (str): A string representing a copulas univariate distribution. Returns: - copulas.univariate: - A copulas univariate class that corresponds to the distribution. + The corresponding copulas univariate class. """ - if not isinstance(distribution, str) or distribution not in cls._DISTRIBUTIONS: - error_message = f"Invalid distribution specification '{distribution}'." + if not isinstance(distribution, str): + raise ValueError(f"Distribution specification must be a string, got {type(distribution)}") + # Allow case-insensitive matching. + distribution_key = distribution.lower() + if distribution_key not in cls._DISTRIBUTIONS: + error_message = ( + f"Invalid distribution specification '{distribution}'. " + f"Valid options: {list(cls._DISTRIBUTIONS.keys())}" + ) raise ValueError(error_message) - - return cls._DISTRIBUTIONS[distribution] + return cls._DISTRIBUTIONS[distribution_key] def __init__( self, - metadata, - enforce_min_max_values=True, - enforce_rounding=True, - locales=["en_US"], - numerical_distributions=None, - default_distribution=None, - ): + metadata: Dict[str, str], + enforce_min_max_values: bool = True, + enforce_rounding: bool = True, + locales: Union[List[str], str] = "en_US", + numerical_distributions: Optional[Dict[str, str]] = None, + default_distribution: Optional[str] = None, + ) -> None: super().__init__(metadata, enforce_min_max_values, enforce_rounding, locales) - validate_numerical_distributions(numerical_distributions, self.metadata.columns) - - self.default_distribution = default_distribution or "beta" - self._default_distribution = self.get_distribution_class( - self.default_distribution - ) - + # Validate numerical distributions using metadata keys. + validate_numerical_distributions(numerical_distributions, list(self.metadata.keys())) + self.default_distribution: str = default_distribution or "beta" + self._default_distribution = self.get_distribution_class(self.default_distribution) self._set_numerical_distributions(numerical_distributions) - self._num_rows = None + self._num_rows: Optional[int] = None + self._model: Optional[Any] = None + self._fitted: bool = False - def _set_numerical_distributions(self, numerical_distributions): + def _set_numerical_distributions(self, numerical_distributions: Optional[Dict[str, str]]) -> None: + """ + Sets the numerical distributions to be used during model initialization. + """ self.numerical_distributions = numerical_distributions or {} self._numerical_distributions = { field: self.get_distribution_class(distribution) for field, distribution in self.numerical_distributions.items() } - def _fit(self, processed_data): - """Fit the model to the table. - - Args: - processed_data (pandas.DataFrame): - Data to be learned. + def _learn_num_rows(self, processed_data: pd.DataFrame) -> int: + """ + Learn the number of rows from the processed data. """ - warn_missing_numerical_distributions( - self.numerical_distributions, processed_data.columns - ) - self._num_rows = self._learn_num_rows(processed_data) - numerical_distributions = self._get_numerical_distributions(processed_data) - self._model = self._initialize_model(numerical_distributions) - self._fit_model(processed_data) - - def _learn_num_rows(self, processed_data): return len(processed_data) - def _get_numerical_distributions(self, processed_data): + def _get_numerical_distributions(self, processed_data: pd.DataFrame) -> Dict[str, Any]: + """ + Get a complete dictionary of numerical distributions for all columns in the data. + """ numerical_distributions = deepcopy(self._numerical_distributions) for column in processed_data.columns: if column not in numerical_distributions: - numerical_distributions[column] = self._numerical_distributions.get( - column, self._default_distribution - ) - + numerical_distributions[column] = self._default_distribution return numerical_distributions - def _initialize_model(self, numerical_distributions): + def _initialize_model(self, numerical_distributions: Dict[str, Any]) -> Any: + """ + Initialize the GaussianMultivariate model with the given numerical distributions. + """ return multivariate.GaussianMultivariate(distribution=numerical_distributions) - def _fit_model(self, processed_data): + def _fit_model(self, processed_data: pd.DataFrame) -> None: + """ + Fit the GaussianMultivariate model on the processed data. + """ with warnings.catch_warnings(): warnings.filterwarnings("ignore", module="scipy") self._model.fit(processed_data) - def _warn_quality_and_performance(self, column_name_to_transformer): - """Raise warning if the quality/performance may be impacted. - + + def fit(self, processed_data: pd.DataFrame) -> None: + """ + Public API method to fit the Gaussian Copula model on processed data. + Args: - column_name_to_transformer (dict): - Dict mapping column names to transformers to be used for that column. + processed_data (pd.DataFrame): Data that has been preprocessed. """ - for column, transformer in column_name_to_transformer.items(): - if isinstance(transformer, OneHotEncoder): - warnings.warn( - f"Using a OneHotEncoder transformer for column '{column}' " - "may slow down the preprocessing and modeling times." - ) - - def _sample(self, num_rows, conditions=None): - """Sample the indicated number of rows from the model. + warn_missing_numerical_distributions(self.numerical_distributions, list(processed_data.columns)) + self._num_rows = self._learn_num_rows(processed_data) + numerical_distributions = self._get_numerical_distributions(processed_data) + self._model = self._initialize_model(numerical_distributions) + self._fit_model(processed_data) + self._fitted = True + def sample(self, num_rows: int, conditions: Optional[Dict[str, Any]] = None) -> pd.DataFrame: + """ + Public API method to sample synthetic data from the fitted model. + Args: - num_rows (int): - Amount of rows to sample. - conditions (dict): - If specified, this dictionary maps column names to the column - value. Then, this method generates ``num_rows`` samples, all of - which are conditioned on the given variables. - + num_rows (int): Number of rows to sample. + conditions (Optional[Dict[str, Any]]): Optional conditions for sampling. + Returns: - pandas.DataFrame: - Sampled data. + pd.DataFrame: A DataFrame containing the synthetic samples. """ + if not self._fitted or self._model is None: + raise ValueError("Model is not fitted yet. Please call fit() before sampling.") return self._model.sample(num_rows, conditions=conditions) - def _get_valid_columns_from_metadata(self, columns): - - valid_columns = [] - for column in columns: - for valid_column in self.metadata.columns: - if column.startswith(valid_column): - valid_columns.append(column) - break - - return valid_columns - - def get_learned_distributions(self): - """Get the marginal distributions used by the ``GaussianCopula``. - - Return a dictionary mapping the column names with the distribution name and the learned - parameters for those. - + def get_learned_distributions(self) -> Dict[str, Any]: + """ + Get the marginal distributions used by the Gaussian Copula. + Returns: - dict: - Dictionary containing the distributions used or detected for each column and the - learned parameters for those. + Dict[str, Any]: A dictionary mapping column names to the distribution name and learned parameters. + + Raises: + ValueError: If the model has not been fitted. """ - if not self._fitted: - raise ValueError( - "Distributions have not been learned yet. Please fit your model first using 'fit'." - ) - + if not self._fitted or self._model is None: + raise ValueError("Distributions have not been learned yet. Please fit your model first using 'fit()'.") if not hasattr(self._model, "to_dict") or not self._model.to_dict(): return {} - parameters = self._model.to_dict() - columns = parameters["columns"] - univariates = deepcopy(parameters["univariates"]) - learned_distributions = {} + columns = parameters.get("columns", []) + univariates = deepcopy(parameters.get("univariates", [])) + learned_distributions: Dict[str, Any] = {} valid_columns = self._get_valid_columns_from_metadata(columns) for column, learned_params in zip(columns, univariates): if column in valid_columns: - distribution = self.numerical_distributions.get( - column, self.default_distribution - ) - learned_params.pop("type") + distribution = self.numerical_distributions.get(column, self.default_distribution) + learned_params.pop("type", None) learned_distributions[column] = { "distribution": distribution, "learned_parameters": learned_params, } - return learned_distributions - def _get_parameters(self): - """Get copula model parameters. - - Compute model ``correlation`` and ``distribution.std`` - before it returns the flatten dict. - + def _get_valid_columns_from_metadata(self, columns: List[str]) -> List[str]: + """ + Extract valid columns based on the metadata. + + Args: + columns (List[str]): List of column names. + Returns: - dict: - Copula parameters. + List[str]: Valid column names found in metadata. + """ + valid_columns: List[str] = [] + for column in columns: + for valid_column in self.metadata.keys(): + if column.startswith(valid_column): + valid_columns.append(column) + break + return valid_columns + def _get_parameters(self) -> Dict[str, Any]: + """ + Get the parameters of the copula model. + + Returns: + Dict[str, Any]: A flattened dictionary containing copula parameters. """ + # Ensure univariates are in their base instance form if applicable. for univariate in self._model.univariates: - univariate_type = type(univariate) - if univariate_type is copulas.univariate.Univariate: + if isinstance(univariate, copulas.univariate.Univariate): univariate = univariate._instance - params = self._model.to_dict() - correlation = [] - for index, row in enumerate(params["correlation"][1:]): + for index, row in enumerate(params.get("correlation", [])[1:]): correlation.append(row[: index + 1]) - params["correlation"] = correlation - params["univariates"] = dict(zip(params.pop("columns"), params["univariates"])) + params["univariates"] = dict(zip(params.get("columns", []), params.get("univariates", []))) params["num_rows"] = self._num_rows - return flatten_dict(params) - - @staticmethod - def _get_nearest_correlation_matrix(matrix): - """Find the nearest correlation matrix. - - If the given matrix is not Positive Semi-definite, which means - that any of its eigenvalues is negative, find the nearest PSD matrix - by setting the negative eigenvalues to 0 and rebuilding the matrix - from the same eigenvectors and the modified eigenvalues. - - After this, the matrix will be PSD but may not have 1s in the diagonal, - so the diagonal is replaced by 1s and then the PSD condition of the - matrix is validated again, repeating the process until the built matrix - contains 1s in all the diagonal and is PSD. - - After 10 iterations, the last step is skipped and the current PSD matrix - is returned even if it does not have all 1s in the diagonal. - - Insipired by: https://stackoverflow.com/a/63131250 + + @classmethod + def _get_nearest_correlation_matrix(cls, matrix: np.ndarray) -> np.ndarray: + """ + Find the nearest Positive Semi-definite (PSD) correlation matrix. + Iteratively adjust negative eigenvalues up to a maximum number of iterations. + + Args: + matrix (np.ndarray): Input correlation matrix. + + Returns: + np.ndarray: Adjusted correlation matrix that is PSD and has ones on the diagonal. """ eigenvalues, eigenvectors = scipy.linalg.eigh(matrix) - negative = eigenvalues < 0 - identity = np.identity(len(matrix)) - iterations = 0 - while np.any(negative): - eigenvalues[negative] = 0 - matrix = eigenvectors.dot(np.diag(eigenvalues)).dot(eigenvectors.T) - if iterations >= 10: - break - - matrix = matrix - matrix * identity + identity - - max_value = np.abs(np.abs(matrix).max()) + identity = np.identity(len(matrix)) + while np.any(eigenvalues < 0) and iterations < cls._MAX_CORR_ITERATIONS: + # Set negative eigenvalues to zero. + eigenvalues[eigenvalues < 0] = 0 + matrix = eigenvectors @ np.diag(eigenvalues) @ eigenvectors.T + # Force ones on the diagonal. + matrix = matrix - np.diag(np.diag(matrix)) + np.identity(len(matrix)) + max_value = np.abs(matrix).max() if max_value > 1: matrix /= max_value - eigenvalues, eigenvectors = scipy.linalg.eigh(matrix) - negative = eigenvalues < 0 iterations += 1 - + if iterations >= cls._MAX_CORR_ITERATIONS and np.any(eigenvalues < 0): + LOGGER.warning("Correlation matrix did not converge to PSD within maximum iterations.") return matrix - def _set_parameters(self, parameters, default_params=None): - """Set copula model parameters. - + def _set_parameters(self, parameters: Dict[str, Any], default_params: Optional[Dict[str, Any]] = None) -> None: + """ + Set copula model parameters based on a flattened parameter dictionary. + Args: - params [dict]: - Copula flatten parameters. - default_params [list]: - Flattened list of parameters to fall back to if `params` are invalid. - + parameters (Dict[str, Any]): Flattened dictionary of model parameters. + default_params (Optional[Dict[str, Any]]): Default parameters to fall back on if provided. """ if default_params is not None: default_params = unflatten_dict(default_params) else: default_params = {} - parameters = unflatten_dict(parameters) if "num_rows" in parameters: num_rows = parameters.pop("num_rows") self._num_rows = 0 if pd.isna(num_rows) else max(0, int(round(num_rows))) - if parameters: parameters = self._rebuild_gaussian_copula(parameters, default_params) self._model = multivariate.GaussianMultivariate.from_dict(parameters) + self._fitted = True - def _rebuild_gaussian_copula(self, model_parameters, default_params=None): - """Rebuild the model params to recreate a Gaussian Multivariate instance. - + def _rebuild_gaussian_copula(self, model_parameters: Dict[str, Any], default_params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: + """ + Rebuild the model parameters to recreate a Gaussian Multivariate instance. + Args: - model_parameters (dict): - Sampled and reestructured model parameters. - default_parameters (dict): - Fall back parameters if sampled params are invalid. - + model_parameters (Dict[str, Any]): Restructured model parameters. + default_params (Optional[Dict[str, Any]]): Fallback parameters if sampled parameters are invalid. + Returns: - dict: - Model parameters ready to recreate the model. + Dict[str, Any]: Model parameters ready for GaussianMultivariate instantiation. """ if default_params is None: default_params = {} - - columns = [] - univariates = [] - for column, univariate in model_parameters["univariates"].items(): + columns: List[str] = [] + univariates: List[Dict[str, Any]] = [] + for column, univariate in model_parameters.get("univariates", {}).items(): columns.append(column) if column in self._numerical_distributions: univariate_type = self._numerical_distributions[column] else: univariate_type = self.get_distribution_class(self.default_distribution) - univariate["type"] = univariate_type - model = univariate_type.MODEL_CLASS - if hasattr(model, "_argcheck"): - to_check = { - parameter: univariate[parameter] - for parameter in inspect.signature( - model._argcheck - ).parameters.keys() - if parameter in univariate - } - if not model._argcheck(**to_check): - if column in default_params.get("univariates", []): - LOGGER.info( - f"Invalid parameters sampled for column '{column}', " - "using default parameters." - ) - univariate = default_params["univariates"][column] - univariate["type"] = univariate_type - else: - LOGGER.debug(f"Column '{column}' has invalid parameters.") + model = getattr(univariate_type, "MODEL_CLASS", None) + if model and hasattr(model, "_argcheck"): + try: + # Extract the parameters required for _argcheck. + arg_names = list(inspect.signature(model._argcheck).parameters.keys()) + to_check = {parameter: univariate[parameter] for parameter in arg_names if parameter in univariate} + if not model._argcheck(**to_check): + if "univariates" in default_params and column in default_params["univariates"]: + LOGGER.info( + f"Invalid parameters for column '{column}', falling back to default parameters." + ) + univariate = default_params["univariates"][column] + univariate["type"] = univariate_type + else: + LOGGER.debug(f"Column '{column}' has invalid parameters.") + except Exception as e: + LOGGER.error(f"Error during parameter check for column '{column}': {e}") else: - LOGGER.debug( - f"Univariate for col '{column}' does not have _argcheck method." - ) - + LOGGER.debug(f"Univariate for column '{column}' does not have an _argcheck method.") if "scale" in univariate: univariate["scale"] = max(0, univariate["scale"]) - univariates.append(univariate) - model_parameters["univariates"] = univariates model_parameters["columns"] = columns - correlation = model_parameters.get("correlation") if correlation: - model_parameters["correlation"] = self._rebuild_correlation_matrix( - correlation - ) + model_parameters["correlation"] = self._rebuild_correlation_matrix(correlation) else: model_parameters["correlation"] = [[1.0]] - return model_parameters @classmethod - def _rebuild_correlation_matrix(cls, triangular_correlation): - """Rebuild a valid correlation matrix from its lower half triangle. - - The input of this function is a list of lists of floats of size 1, 2, 3...n-1: - - [[c_{2,1}], [c_{3,1}, c_{3,2}], ..., [c_{n,1},...,c_{n,n-1}]] - - Corresponding to the values from the lower half of the original correlation matrix, - **excluding** the diagonal. - - The output is the complete correlation matrix reconstructed using the given values - and scaled to the :math:`[-1, 1]` range if necessary. - + def _rebuild_correlation_matrix(cls, triangular_correlation: List[List[float]]) -> List[List[float]]: + """ + Rebuild a valid correlation matrix from its lower triangular part. + Args: - triangle_correlation (list[list[float]]): - A list that contains lists of floats of size 1, 2, 3... up to ``n-1``, - where ``n`` is the size of the target correlation matrix. - + triangular_correlation (List[List[float]]): Lower triangular values (excluding the diagonal). + Returns: - numpy.ndarray: - rebuilt correlation matrix. + List[List[float]]: Reconstructed and adjusted full correlation matrix. """ - zero = [0.0] size = len(triangular_correlation) + 1 left = np.zeros((size, size)) right = np.zeros((size, size)) for idx, values in enumerate(triangular_correlation): - values = values + zero * (size - idx - 1) - left[idx + 1, :] = values - right[:, idx + 1] = values - + extended_values = values + [0.0] * (size - idx - 1) + left[idx + 1, :] = extended_values + right[:, idx + 1] = extended_values correlation = left + right max_value = np.abs(correlation).max() if max_value > 1: correlation /= max_value - correlation += np.identity(size) - - return cls._get_nearest_correlation_matrix(correlation).tolist() + adjusted_corr = cls._get_nearest_correlation_matrix(correlation) + return adjusted_corr.tolist() diff --git a/synthpop/method/__init__.py b/synthpop/method/__init__.py index e3db882..c338d6e 100644 --- a/synthpop/method/__init__.py +++ b/synthpop/method/__init__.py @@ -1,83 +1,10 @@ -from synthpop.method.base import Method -from synthpop.method.helpers import proper, smooth -from synthpop.method.empty import EmptyMethod -from synthpop.method.sample import SampleMethod -from synthpop.method.cart import CARTMethod -from synthpop.method.norm import NormMethod -from synthpop.method.normrank import NormRankMethod -from synthpop.method.polyreg import PolyregMethod -from synthpop.method.gaussian_copula import GaussianCopulaMethod - -EMPTY_METHOD = '' -SAMPLE_METHOD = 'sample' -# non-parametric methods -CART_METHOD = 'cart' -# parametric methods -PARAMETRIC_METHOD = 'parametric' -NORM_METHOD = 'norm' -NORMRANK_METHOD = 'normrank' -POLYREG_METHOD = 'polyreg' -GC_METHOD = 'gaussian copula' - - -METHODS_MAP = {EMPTY_METHOD: EmptyMethod, - SAMPLE_METHOD: SampleMethod, - CART_METHOD: CARTMethod, - NORM_METHOD: NormMethod, - NORMRANK_METHOD: NormRankMethod, - POLYREG_METHOD: PolyregMethod, - GC_METHOD: GaussianCopulaMethod - } - - -ALL_METHODS = (EMPTY_METHOD, SAMPLE_METHOD, CART_METHOD, PARAMETRIC_METHOD, NORM_METHOD, NORMRANK_METHOD, POLYREG_METHOD, GC_METHOD) -DEFAULT_METHODS = (CART_METHOD, PARAMETRIC_METHOD, GC_METHOD) -INIT_METHODS = (SAMPLE_METHOD, CART_METHOD, PARAMETRIC_METHOD, GC_METHOD) -NA_METHODS = (CART_METHOD, NORM_METHOD, NORMRANK_METHOD, POLYREG_METHOD, GC_METHOD) - - -# method maps -PARAMETRIC_METHOD_MAP = {'int': NORMRANK_METHOD, - 'float': NORMRANK_METHOD, - 'datetime': NORMRANK_METHOD, - 'bool': POLYREG_METHOD, - 'category': POLYREG_METHOD - } - -CART_METHOD_MAP = {'int': CART_METHOD, - 'float': CART_METHOD, - 'datetime': CART_METHOD, - 'bool': CART_METHOD, - 'category': CART_METHOD - } - -GC_METHOD_MAP = {'int': GC_METHOD, - 'float': GC_METHOD, - 'datetime': GC_METHOD, - 'bool': GC_METHOD, - 'category': GC_METHOD - } - -SAMPLE_METHOD_MAP = {'int': SAMPLE_METHOD, - 'float': SAMPLE_METHOD, - 'datetime': SAMPLE_METHOD, - 'bool': SAMPLE_METHOD, - 'category': SAMPLE_METHOD - } - -DEFAULT_METHODS_MAP = {CART_METHOD: CART_METHOD_MAP, - PARAMETRIC_METHOD: PARAMETRIC_METHOD_MAP, - GC_METHOD: GC_METHOD_MAP - } - - -INIT_METHODS_MAP = DEFAULT_METHODS_MAP.copy() -INIT_METHODS_MAP[SAMPLE_METHOD] = SAMPLE_METHOD_MAP - - -CONT_TO_CAT_METHODS_MAP = {CART_METHOD: CART_METHOD, - NORM_METHOD: POLYREG_METHOD, - NORMRANK_METHOD: POLYREG_METHOD, - POLYREG_METHOD: POLYREG_METHOD, - GC_METHOD: GC_METHOD - } +from .cart import CARTMethod +from .GC import GaussianCopulaMethod # or from .gaussian_copula import GaussianCopulaMethod +from .helpers import proper, smooth + +__all__ = [ + "CARTMethod", + "GaussianCopulaMethod", + "proper", + "smooth", +] \ No newline at end of file diff --git a/synthpop/method/cart.py b/synthpop/method/cart.py index c5f580a..eaf227d 100644 --- a/synthpop/method/cart.py +++ b/synthpop/method/cart.py @@ -1,56 +1,151 @@ import numpy as np import pandas as pd from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor +import logging +from synthpop.method.helpers import proper, smooth +from synthpop.constants import NUM_COLS_DTYPES, CAT_COLS_DTYPES -from synthpop.method import Method, proper, smooth -# global variables -from synthpop import NUM_COLS_DTYPES, CAT_COLS_DTYPES +# Set up logging +LOGGER = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) -class CARTMethod(Method): - def __init__(self, dtype, smoothing=False, proper=False, minibucket=5, random_state=None, *args, **kwargs): - self.dtype = dtype +class CARTMethod: + """ + + + Attributes: + metadata (dict): Mapping of column names to abstract data types + (e.g., "numerical", "categorical", "boolean", "datetime", "timedelta"). + smoothing (bool): Whether to apply smoothing to numerical predictions. + proper (bool): Whether to apply a resampling (proper) step during fitting. + minibucket (int): Minimum samples per leaf in the decision tree. + random_state (int or None): Random seed. + tree_params (dict): Additional parameters to pass to the decision tree constructors. + """ + def __init__(self, metadata, smoothing=False, proper=False, minibucket=5, random_state=None, tree_params=None): + self.metadata = metadata self.smoothing = smoothing self.proper = proper self.minibucket = minibucket self.random_state = random_state + self.tree_params = tree_params or {} + self.models = {} # Dict: column -> fitted decision tree model + self.leaf_values = {} # Dict: column -> dict mapping leaf id -> array of training y values + self.y_bounds = {} # Dict: column -> (y_real_min, y_real_max) for numerical columns + self.fitted = False + self._train_data = None # Copy of preprocessed training data - if self.dtype in CAT_COLS_DTYPES: - self.cart = DecisionTreeClassifier(min_samples_leaf=self.minibucket, random_state=self.random_state) - if self.dtype in NUM_COLS_DTYPES: - self.cart = DecisionTreeRegressor(min_samples_leaf=self.minibucket, random_state=self.random_state) - - def fit(self, X_df, y_df): - if self.proper: - X_df, y_df = proper(X_df=X_df, y_df=y_df, random_state=self.random_state) - - X_df, y_df = self.prepare_dfs(X_df=X_df, y_df=y_df, normalise_num_cols=False, one_hot_cat_cols=True) - if self.dtype in NUM_COLS_DTYPES: - self.y_real_min, self.y_real_max = np.min(y_df), np.max(y_df) - - X = X_df.to_numpy() - y = y_df.to_numpy() - self.cart.fit(X, y) - - # save the y distribution wrt trained tree nodes - leaves = self.cart.apply(X) - leaves_y_df = pd.DataFrame({'leaves': leaves, 'y': y}) - self.leaves_y_dict = leaves_y_df.groupby('leaves').apply(lambda x: x.to_numpy()[:, -1]).to_dict() - - def predict(self, X_test_df): - X_test_df, _ = self.prepare_dfs(X_df=X_test_df, normalise_num_cols=False, one_hot_cat_cols=True, fit=False) - - # predict the leaves and for each leaf randomly sample from the observed values - X_test = X_test_df.to_numpy() - leaves_pred = self.cart.apply(X_test) - y_pred = np.zeros(len(leaves_pred), dtype=object) + def fit(self, data: pd.DataFrame) -> None: + """ + Fit a CART model for each column using the remaining columns as predictors. + For numerical (and related) columns, stores the min and max of y for smoothing. + Uses the 'proper' function to optionally resample the data. + + Args: + data (pd.DataFrame): Preprocessed data. + """ + self._train_data = data.copy() + for col in data.columns: + # Prepare predictors (X) and target (y) + X = data.drop(columns=[col]) + y = data[col] + if self.proper: + X, y = proper(X_df=X, y_df=y, random_state=self.random_state) + dtype = self.metadata.get(col, "numerical") + # Choose the appropriate decision tree + if dtype in ["numerical", "datetime", "timedelta"]: + model = DecisionTreeRegressor(min_samples_leaf=self.minibucket, random_state=self.random_state, **self.tree_params) + # Store bounds for smoothing + self.y_bounds[col] = (np.min(y.to_numpy()), np.max(y.to_numpy())) + elif dtype in ["categorical", "boolean"]: + model = DecisionTreeClassifier(min_samples_leaf=self.minibucket, random_state=self.random_state, **self.tree_params) + else: + warnings.warn(f"Unknown data type for column '{col}', defaulting to regressor.") + model = DecisionTreeRegressor(min_samples_leaf=self.minibucket, random_state=self.random_state, **self.tree_params) + try: + X_np = X.to_numpy() + y_np = y.to_numpy() + model.fit(X_np, y_np) + self.models[col] = model + # Compute leaf indices for training data and group target values by leaf. + leaves = model.apply(X_np) + df_leaves = pd.DataFrame({'leaf': leaves, 'y': y_np}) + leaf_dict = df_leaves.groupby('leaf')['y'].apply(lambda arr: arr.values).to_dict() + self.leaf_values[col] = leaf_dict + except Exception as e: + LOGGER.error(f"Error fitting model for column '{col}': {e}") + self.fitted = True - leaves_pred_index_df = pd.DataFrame({'leaves_pred': leaves_pred, 'index': range(len(leaves_pred))}) - leaves_pred_index_dict = leaves_pred_index_df.groupby('leaves_pred').apply(lambda x: x.to_numpy()[:, -1]).to_dict() - for leaf, indices in leaves_pred_index_dict.items(): - y_pred[indices] = np.random.choice(self.leaves_y_dict[leaf], size=len(indices), replace=True) + def predict(self, X_test: pd.DataFrame) -> pd.DataFrame: + """ + Generate synthetic predictions using leaf-based sampling. + For each column, the method predicts the leaf for each test row and then samples + randomly from the training values associated with that leaf. + Optionally applies smoothing to numerical columns. + + Args: + X_test (pd.DataFrame): Preprocessed predictors (should contain same columns as training data). + + Returns: + pd.DataFrame: A DataFrame with synthetic predictions for each column. + """ + if not self.fitted: + raise ValueError("The model must be fitted before prediction.") + + predictions = {} + for col, model in self.models.items(): + dtype = self.metadata.get(col, "numerical") + # Prepare predictors for this column (drop the target if present) + X = X_test.drop(columns=[col], errors='ignore') + X_np = X.to_numpy() + # Get leaf indices for test data + leaves_pred = model.apply(X_np) + y_pred = np.empty(len(leaves_pred), dtype=object) + # Group indices by leaf + leaf_indices = pd.DataFrame({'leaf': leaves_pred, 'index': range(len(leaves_pred))}) \ + .groupby('leaf')['index'].apply(list).to_dict() + for leaf, indices in leaf_indices.items(): + if leaf in self.leaf_values[col]: + samples = np.random.choice(self.leaf_values[col][leaf], size=len(indices), replace=True) + else: + # Fallback: if unseen leaf, use direct prediction. + samples = model.predict(X_np[indices]) + for i, idx in enumerate(indices): + y_pred[idx] = samples[i] + y_pred = np.array(y_pred) + # Apply smoothing if enabled and if numeric/datetime/timedelta + if self.smoothing and dtype in ["numerical", "datetime", "timedelta"]: + y_real_min, y_real_max = self.y_bounds[col] + y_pred = smooth(dtype, y_pred, y_real_min, y_real_max) + predictions[col] = y_pred + return pd.DataFrame(predictions) + + def sample(self, num_rows: int) -> pd.DataFrame: + """ + Generate synthetic data with a specified number of rows. + + The predictor sampling uses the maximum of the requested number of rows + and the size of the original training data (to ensure the trees see as much data + as possible). However, the returned DataFrame has the user-specified number of rows. + + Args: + num_rows (int): The number of synthetic samples to generate. + + Returns: + pd.DataFrame: A DataFrame containing synthetic data with num_rows rows. + """ + if not self.fitted: + raise ValueError("The model must be fitted before generating synthetic data.") + + # Use the maximum between num_rows and the original data size for predictor sampling + sample_size = max(num_rows, len(self._train_data)) + synthetic_input = self._train_data.sample(n=sample_size, replace=True, random_state=self.random_state) + + # Generate synthetic data using the predict method + synthetic_full = self.predict(synthetic_input) + + # Return only the first num_rows synthetic observations + return synthetic_full.iloc[:num_rows].reset_index(drop=True) - if self.smoothing and self.dtype in NUM_COLS_DTYPES: - y_pred = smooth(self.dtype, y_pred, self.y_real_min, self.y_real_max) - return y_pred diff --git a/synthpop/method/gaussian_copula.py b/synthpop/method/gaussian_copula.py deleted file mode 100644 index f1e60cd..0000000 --- a/synthpop/method/gaussian_copula.py +++ /dev/null @@ -1,106 +0,0 @@ -import numpy as np -import pandas as pd -from scipy.stats import norm, ks_2samp -# from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor - -from synthpop.method import Method, proper, smooth -# global variables -# from synthpop import NUM_COLS_DTYPES, CAT_COLS_DTYPES - - -class GaussianCopulaMethod(Method): - def __init__(self, dtype, smoothing=False, proper=False, minibucket=5, random_state=None, *args, **kwargs): - self.dtype = dtype - self.proper = proper - self.random_state = random_state - self.smoothing = smoothing - self.minibucket = minibucket - - # learnt parameters - self.means = None - self.cov_matrix = None - self.scaler = None - self.data_marginals = None - - def fit(self, data): - """ - Fit the Gaussian Copula model to the given data. - """ - # Step 1: Store data marginals (quantiles for each feature) - self.data_marginals = [] - for col in data.columns: - sorted_data = np.sort(data[col]) - quantiles = np.linspace(0, 1, len(sorted_data)) - self.data_marginals.append((sorted_data, quantiles, col)) - - # Step 2: Convert data to normal distribution using CDF (Gaussianization) - uniform_data = data.rank(pct=True) # Get percentile rank for each column (empirical CDF) - gaussian_data = norm.ppf(uniform_data) # Convert uniform to standard normal - - # Step 3: Fit a multivariate Gaussian to the normalized data - self.means = gaussian_data.mean(axis=0) - self.cov_matrix = np.cov(gaussian_data, rowvar=False) - - def predict(self, n_samples): - """ - Generate synthetic data using the fitted Gaussian Copula model. - """ - # Step 1: Sample from the multivariate normal distribution - synthetic_gaussian = np.random.multivariate_normal(self.means, self.cov_matrix, n_samples) - - # Step 2: Convert back to uniform distribution using CDF (normal -> uniform) - synthetic_uniform = norm.cdf(synthetic_gaussian) - - # Step 3: Map uniform data back to the original marginals - synthetic_data = pd.DataFrame() - for i, (sorted_data, quantiles, col) in enumerate(self.data_marginals): - synthetic_data[col] = np.interp(synthetic_uniform[:, i], quantiles, sorted_data) - - return synthetic_data - -def evaluate_distribution(real_data, synthetic_data): - """ - Compare the distribution of each column in the real and synthetic data using - the Kolmogorov-Smirnov (KS) test. - """ - results = {} - for column in real_data.columns: - real_col = real_data[column].dropna() - synthetic_col = synthetic_data[column].dropna() - - # Perform the KS test - ks_stat, p_value = ks_2samp(real_col, synthetic_col) - - # Store the result - results[column] = {'ks_stat': ks_stat, 'p_value': p_value} - return results - -def evaluate_correlations(real_data, synthetic_data): - """ - Compare the pairwise correlation matrices of the real and synthetic data. - """ - real_corr = real_data.corr() - synthetic_corr = synthetic_data.corr() - - # Compute the difference between the correlation matrices - corr_diff = np.abs(real_corr - synthetic_corr) - return corr_diff.mean().mean() # Average correlation difference - -def run_diagnostic(real_data, synthetic_data, target_column): - """ - Run diagnostics on synthetic data by evaluating distribution, correlations, and - classification model performance. - """ - # Step 1: Evaluate distributions - distribution_results = evaluate_distribution(real_data, synthetic_data) - - # Step 2: Evaluate correlations - correlation_diff = evaluate_correlations(real_data, synthetic_data) - - # Aggregate results - diagnostics = { - 'distribution_results': distribution_results, - 'correlation_diff': correlation_diff - } - - return diagnostics \ No newline at end of file diff --git a/synthpop/method/helpers.py b/synthpop/method/helpers.py index 39aaa2b..7f227e1 100644 --- a/synthpop/method/helpers.py +++ b/synthpop/method/helpers.py @@ -1,4 +1,5 @@ import numpy as np +import pandas as pd from scipy.stats import mode, iqr @@ -15,31 +16,26 @@ def proper(X_df=None, y_df=None, random_state=None): def smooth(dtype, y_synth, y_real_min, y_real_max): + # Ensure y_synth is numeric (float) before proceeding. + y_synth = np.asarray(y_synth, dtype=float) + indices = [True for _ in range(len(y_synth))] - # exclude from smoothing if freq for a single value higher than 70% + # Exclude from smoothing if frequency for a single value is higher than 70% y_synth_mode = mode(y_synth) if y_synth_mode.count / len(y_synth) > 0.7: indices = np.logical_and(indices, y_synth != y_synth_mode.mode) - # exclude from smoothing if data are top-coded - approximate check + # Exclude from smoothing if data are top-coded - approximate check y_synth_sorted = np.sort(y_synth) - top_coded = 10 * np.abs(y_synth_sorted[-2]) < np.abs(y_synth_sorted[-1]) - np.abs(y_synth_sorted[-2]) + top_coded = 10 * np.abs(y_synth_sorted[-2]) < np.abs(y_synth_sorted[-1] - y_synth_sorted[-2]) if top_coded: indices = np.logical_and(indices, y_synth != y_real_max) - # R version - # http://www.bagualu.net/wordpress/wp-content/uploads/2015/10/Modern_Applied_Statistics_With_S.pdf - # R default (ned0) - [link eq5.5 in p127] - this is used as the other one is not a closed formula - # R recommended (SJ) - [link eq5.6 in p129] - bw = 0.9 * len(y_synth[indices]) ** -1/5 * np.minimum(np.std(y_synth[indices]), iqr(y_synth[indices]) / 1.34) - - # # Python version - much slower as it's not a closed formula and requires a girdsearch - # bandwidths = 10 ** np.linspace(-1, 1, 10) - # grid = GridSearchCV(KernelDensity(kernel='gaussian'), {'bandwidth': bandwidths}, cv=3, iid=False) - # grid.fit(y_synth[indices, None]) - # bw = grid.best_estimator_.bandwidth + # Compute bandwidth using the provided formula + bw = 0.9 * len(y_synth[indices]) ** (-1/5) * np.minimum(np.std(y_synth[indices]), iqr(y_synth[indices]) / 1.34) + # Apply smoothing: for values flagged by indices, sample from a normal distribution y_synth[indices] = np.array([np.random.normal(loc=value, scale=bw) for value in y_synth[indices]]) if not top_coded: y_real_max += bw @@ -50,6 +46,7 @@ def smooth(dtype, y_synth, y_real_min, y_real_max): return y_synth + def validate_numerical_distributions(numerical_distributions, metadata_columns): """Validate ``numerical_distributions``. diff --git a/synthpop/method/test_method.ipynb b/synthpop/method/test_method.ipynb deleted file mode 100644 index e69de29..0000000 diff --git a/synthpop/metrics/__init__.py b/synthpop/metrics/__init__.py new file mode 100644 index 0000000..b1599ca --- /dev/null +++ b/synthpop/metrics/__init__.py @@ -0,0 +1,29 @@ +# __init__.py + +from .diagnostic_report import MetricsReport +from .efficacy_metrics import EfficacyMetrics +from .privacy_metrics import DisclosureProtection +from .single_columns_metrics import ( + category_coverage, + range_coverage, + boundary_adherence, + category_adherence, + ks_complement, + tv_complement, + statistic_similarity, + missing_value_similarity +) + +__all__ = [ + "MetricsReport", + "EfficacyMetrics", + "DisclosureProtection", + "category_coverage", + "range_coverage", + "boundary_adherence", + "category_adherence", + "ks_complement", + "tv_complement", + "statistic_similarity", + "missing_value_similarity" +] diff --git a/synthpop/metrics/diagnostic_report.py b/synthpop/metrics/diagnostic_report.py new file mode 100644 index 0000000..8c0ce4f --- /dev/null +++ b/synthpop/metrics/diagnostic_report.py @@ -0,0 +1,107 @@ +# metrics_report.py + +import pandas as pd +import numpy as np +from .single_columns_metrics import ( + category_coverage, + range_coverage, + boundary_adherence, + category_adherence, + ks_complement, + tv_complement, + statistic_similarity, + missing_value_similarity +) + +class MetricsReport: + """ + A class to produce a report comparing real and synthetic datasets with respect + to data validity and data structure. + + The report computes the following metrics for each column: + - For numerical (or datetime/timedelta) columns: + * Range Coverage: Proportion of the real data's range covered by the synthetic data. + * Boundary Adherence: Fraction of synthetic values within the real data's min/max. + * KS Complement: 1 minus the Kolmogorov-Smirnov statistic. + * TV Complement: 1 minus the Total Variation distance computed over histograms. + * Statistic Similarity: Similarity of mean, std, and median. + * Missing Value Similarity: Similarity in the proportion of missing values. + - For categorical (or boolean) columns: + * Category Coverage: Proportion of real categories found in synthetic data. + * Category Adherence: Fraction of synthetic values that are valid real categories. + * Missing Value Similarity. + + Optionally, you may provide a metadata dictionary mapping column names to abstract types. + If metadata is not provided, the type is inferred from the pandas dtype. + """ + + def __init__(self, real_df: pd.DataFrame, synthetic_df: pd.DataFrame, metadata: dict = None): + """ + Args: + real_df (pd.DataFrame): The real dataset. + synthetic_df (pd.DataFrame): The synthetic dataset. + metadata (dict, optional): Mapping from column names to types (e.g., "numerical", + "categorical", "boolean", "datetime", "timedelta"). If not provided, types are inferred. + """ + self.real_df = real_df + self.synthetic_df = synthetic_df + # If no metadata is provided, infer types based on the dtype string. + if metadata is None: + metadata = {} + for col in real_df.columns: + dtype = str(real_df[col].dtype) + if "float" in dtype or "int" in dtype: + metadata[col] = "numerical" + elif "datetime" in dtype: + metadata[col] = "datetime" + elif "timedelta" in dtype: + metadata[col] = "timedelta" + elif "bool" in dtype: + metadata[col] = "boolean" + else: + metadata[col] = "categorical" + self.metadata = metadata + + def generate_report(self) -> pd.DataFrame: + """ + Generate a report comparing the real and synthetic datasets. + + Returns: + pd.DataFrame: A DataFrame where each row corresponds to a column in the data and + contains computed metrics. Non-applicable metrics are marked as 'N/A'. + """ + report_data = [] + for col in self.real_df.columns: + col_type = self.metadata.get(col, "numerical") + real = self.real_df[col] + synthetic = self.synthetic_df[col] + col_report = {"column": col, "type": col_type} + + # Missing value similarity applies to all columns. + col_report["missing_value_similarity"] = missing_value_similarity(real, synthetic) + + # For numerical/datetime/timedelta columns, compute numerical metrics and mark categorical metrics as 'N/A' + if col_type in ["numerical", "datetime", "timedelta"]: + col_report["range_coverage"] = range_coverage(real, synthetic) + col_report["boundary_adherence"] = boundary_adherence(real, synthetic) + col_report["ks_complement"] = ks_complement(real, synthetic) + col_report["tv_complement"] = tv_complement(real, synthetic) + col_report["statistic_similarity"] = statistic_similarity(real, synthetic) + col_report["category_coverage"] = "N/A" + col_report["category_adherence"] = "N/A" + + # For categorical/boolean columns, compute categorical metrics and mark numerical metrics as 'N/A' + elif col_type in ["categorical", "boolean"]: + col_report["range_coverage"] = "N/A" + col_report["boundary_adherence"] = "N/A" + col_report["ks_complement"] = "N/A" + col_report["tv_complement"] = "N/A" + col_report["statistic_similarity"] = "N/A" + col_report["category_coverage"] = category_coverage(real, synthetic) + col_report["category_adherence"] = category_adherence(real, synthetic) + + else: + col_report["note"] = "Unknown type; metrics not computed" + + report_data.append(col_report) + return pd.DataFrame(report_data) diff --git a/synthpop/metrics/efficacy_metrics.py b/synthpop/metrics/efficacy_metrics.py new file mode 100644 index 0000000..c0edcd1 --- /dev/null +++ b/synthpop/metrics/efficacy_metrics.py @@ -0,0 +1,101 @@ +# efficacy_metrics.py + +import numpy as np +import pandas as pd +from sklearn.linear_model import LinearRegression +from sklearn.tree import DecisionTreeClassifier +from sklearn.metrics import ( + mean_squared_error, + mean_absolute_error, + r2_score, + accuracy_score, + f1_score +) +from sklearn.model_selection import train_test_split + +class EfficacyMetrics: + """ + A class to compute efficacy metrics comparing real and synthetic datasets + for downstream predictive tasks. The idea is to train a predictive model on + synthetic data and evaluate its performance on real data. The type of metrics + computed depends on the task: + + - For regression (when the target is numerical): + * Mean Squared Error (MSE) + * Mean Absolute Error (MAE) + * R^2 Score + + - For classification (when the target is categorical/boolean): + * Accuracy Score + * Weighted F1 Score + + Parameters + ---------- + task : str, optional (default='regression') + The predictive task type. Must be either 'regression' or 'classification'. + target_column : str + The name of the target column. Must exist in both real and synthetic data. + test_size : float, optional (default=0.3) + (Optional) Proportion of the real data to be used for testing. + (Note: In the default approach we train on all synthetic data and test on full real data.) + random_state : int, optional (default=42) + Random seed for reproducibility. + """ + + def __init__(self, task='regression', target_column=None, test_size=0.3, random_state=42): + if task not in ['regression', 'classification']: + raise ValueError("Task must be either 'regression' or 'classification'.") + if target_column is None: + raise ValueError("A target column must be specified.") + + self.task = task + self.target_column = target_column + self.test_size = test_size + self.random_state = random_state + + def evaluate(self, real_df: pd.DataFrame, synthetic_df: pd.DataFrame) -> dict: + """ + Evaluate the efficacy of synthetic data by training a model on synthetic data + and testing its performance on real data. + + Args: + real_df (pd.DataFrame): The real dataset. + synthetic_df (pd.DataFrame): The synthetic dataset. + + Returns: + dict: A dictionary of performance metrics. + """ + # Verify that the target column exists in both datasets. + if self.target_column not in real_df.columns or self.target_column not in synthetic_df.columns: + raise ValueError("The target column must exist in both real and synthetic datasets.") + + # Separate features and target. + X_syn = synthetic_df.drop(columns=[self.target_column]) + y_syn = synthetic_df[self.target_column] + X_real = real_df.drop(columns=[self.target_column]) + y_real = real_df[self.target_column] + + # For the purposes of efficacy metrics, we train on synthetic data and test on real data. + if self.task == 'regression': + model = LinearRegression() + model.fit(X_syn, y_syn) + predictions = model.predict(X_real) + mse = mean_squared_error(y_real, predictions) + mae = mean_absolute_error(y_real, predictions) + r2 = r2_score(y_real, predictions) + return { + "mse": mse, + "mae": mae, + "r2": r2 + } + else: # classification + model = DecisionTreeClassifier(random_state=self.random_state) + model.fit(X_syn, y_syn) + predictions = model.predict(X_real) + accuracy = accuracy_score(y_real, predictions) + f1 = f1_score(y_real, predictions, average='weighted') + return { + "accuracy": accuracy, + "f1_score": f1 + } + diff --git a/synthpop/metrics/privacy_metrics.py b/synthpop/metrics/privacy_metrics.py new file mode 100644 index 0000000..211c315 --- /dev/null +++ b/synthpop/metrics/privacy_metrics.py @@ -0,0 +1,86 @@ +# privacy_metrics.py + +import numpy as np +import pandas as pd +from sklearn.neighbors import NearestNeighbors + +class DisclosureProtection: + """ + A class to compute the disclosure protection metric for synthetic data. + + The metric is defined as 1 minus the proportion of synthetic records that are too similar + (i.e. within a risk threshold) to a record in the real dataset. + + Parameters + ---------- + real_data : pd.DataFrame + A DataFrame containing the real data. The data should be numeric or preprocessed. + synthetic_data : pd.DataFrame + A DataFrame containing the synthetic data (with the same columns as real_data). + threshold : float, optional + A distance threshold under which a synthetic record is considered a potential disclosure risk. + If not provided, it is computed as the 10th percentile of the nearest-neighbor distances among real records. + """ + + def __init__(self, real_data: pd.DataFrame, synthetic_data: pd.DataFrame, threshold: float = None): + self.real_data = real_data.copy() + self.synthetic_data = synthetic_data.copy() + self.threshold = threshold + self._compute_threshold() + + def _compute_threshold(self): + """ + Compute the threshold if not provided. Uses the 10th percentile of the nearest-neighbor + distances among real records (excluding self-distance). + """ + if self.threshold is None: + # Fit a nearest neighbor model on the real data. + # n_neighbors=2 because the closest neighbor of a record is itself. + nn = NearestNeighbors(n_neighbors=2) + nn.fit(self.real_data) + distances, _ = nn.kneighbors(self.real_data) + # distances[:, 1] are the distances to the closest distinct record. + self.threshold = np.percentile(distances[:, 1], 10) + + def score(self) -> float: + """ + Compute the disclosure protection score. + + For each synthetic record, compute its distance to the nearest real record. + The risk rate is the proportion of synthetic records with distance below the threshold. + The disclosure protection score is 1 - risk_rate (higher is better). + + Returns + ------- + float + Disclosure protection score between 0 and 1. + """ + nn = NearestNeighbors(n_neighbors=1) + nn.fit(self.real_data) + distances, _ = nn.kneighbors(self.synthetic_data) + distances = distances.flatten() + risk_count = np.sum(distances < self.threshold) + risk_rate = risk_count / len(distances) + return 1 - risk_rate + + def report(self) -> dict: + """ + Generate a detailed report of the disclosure protection metric. + + Returns + ------- + dict + A dictionary containing the threshold, risk rate, and the final disclosure protection score. + """ + nn = NearestNeighbors(n_neighbors=1) + nn.fit(self.real_data) + distances, _ = nn.kneighbors(self.synthetic_data) + distances = distances.flatten() + risk_count = np.sum(distances < self.threshold) + risk_rate = risk_count / len(distances) + score = 1 - risk_rate + return { + "threshold": self.threshold, + "risk_rate": risk_rate, + "disclosure_protection_score": score + } diff --git a/synthpop/metrics/single_columns_metrics.py b/synthpop/metrics/single_columns_metrics.py new file mode 100644 index 0000000..38fa5ed --- /dev/null +++ b/synthpop/metrics/single_columns_metrics.py @@ -0,0 +1,253 @@ +# metrics.py + +import numpy as np +import pandas as pd +from scipy.stats import ks_2samp, iqr + +# ------------------------------------------------------------------------------ +# Coverage Metrics +# ------------------------------------------------------------------------------ + +def category_coverage(real: pd.Series, synthetic: pd.Series) -> float: + """ + Measure the proportion of categories present in the real data that are + also present in the synthetic data. + + Args: + real (pd.Series): Real (categorical) data. + synthetic (pd.Series): Synthetic (categorical) data. + + Returns: + float: Ratio (0 to 1) of real categories that are found in the synthetic data. + """ + real_cats = set(real.dropna().unique()) + synth_cats = set(synthetic.dropna().unique()) + if not real_cats: + return 1.0 + return len(real_cats.intersection(synth_cats)) / len(real_cats) + + +def range_coverage(real: pd.Series, synthetic: pd.Series) -> float: + """ + Measure the proportion of the real data's numerical range that is covered by the + synthetic data. If the data is datetime or timedelta, convert it to seconds. + + Args: + real (pd.Series): Real numerical data. + synthetic (pd.Series): Synthetic numerical data. + + Returns: + float: The ratio of the intersection length of the ranges to the real range. + """ + real_min, real_max = real.min(), real.max() + synth_min, synth_max = synthetic.min(), synthetic.max() + + # If the data is datetime, convert to seconds since epoch. + if isinstance(real_min, pd.Timestamp): + real_min = real_min.value / 1e9 # convert nanoseconds to seconds + real_max = real_max.value / 1e9 + synth_min = synth_min.value / 1e9 + synth_max = synth_max.value / 1e9 + # If the data is timedelta, convert to total seconds. + elif isinstance(real_min, pd.Timedelta): + real_min = real_min.total_seconds() + real_max = real_max.total_seconds() + synth_min = synth_min.total_seconds() + synth_max = synth_max.total_seconds() + + if real_max == real_min: + return 1.0 + intersection = max(0, min(real_max, synth_max) - max(real_min, synth_min)) + return intersection / (real_max - real_min) + + +# ------------------------------------------------------------------------------ +# Adherence Metrics +# ------------------------------------------------------------------------------ + +def boundary_adherence(real: pd.Series, synthetic: pd.Series) -> float: + """ + Measure the fraction of synthetic numerical values that lie within the boundaries + of the real data. + + Args: + real (pd.Series): Real numerical data. + synthetic (pd.Series): Synthetic numerical data. + + Returns: + float: The fraction (0 to 1) of synthetic values within [real_min, real_max]. + """ + real_min, real_max = real.min(), real.max() + adherence = ((synthetic >= real_min) & (synthetic <= real_max)).mean() + return adherence + + +def category_adherence(real: pd.Series, synthetic: pd.Series) -> float: + """ + Measure the fraction of synthetic categorical values that are present in the set + of real categories. + + Args: + real (pd.Series): Real categorical data. + synthetic (pd.Series): Synthetic categorical data. + + Returns: + float: The fraction (0 to 1) of synthetic values that are among the real categories. + """ + real_cats = set(real.dropna().unique()) + if not real_cats: + return 1.0 + adherence = synthetic.dropna().apply(lambda x: x in real_cats).mean() + return adherence + +# ------------------------------------------------------------------------------ +# Distribution/Shape Comparison Metrics +# ------------------------------------------------------------------------------ + +def ks_complement(real: pd.Series, synthetic: pd.Series) -> float: + """ + Compute the complement of the Kolmogorov-Smirnov statistic comparing the + real and synthetic data distributions. + + Args: + real (pd.Series): Real numerical data. + synthetic (pd.Series): Synthetic numerical data. + + Returns: + float: 1 - KS statistic (ranges between 0 and 1, where 1 means identical distributions). + """ + real_clean = real.dropna() + synthetic_clean = synthetic.dropna() + if len(real_clean) == 0 or len(synthetic_clean) == 0: + return 0.0 + ks_stat, _ = ks_2samp(real_clean, synthetic_clean) + return 1 - ks_stat + + +def tv_complement(real: pd.Series, synthetic: pd.Series, bins: int = 10) -> float: + """ + Compute the complement of the Total Variation (TV) distance between the histograms + of the real and synthetic data. A value of 1 indicates identical distributions. + + If the data is datetime or timedelta, convert it to numeric values (in seconds). + + Args: + real (pd.Series): Real numerical data. + synthetic (pd.Series): Synthetic numerical data. + bins (int, optional): Number of bins to use for the histograms. Defaults to 10. + + Returns: + float: 1 - TV distance, where TV is computed over the normalized histograms. + """ + real_clean = real.dropna() + synthetic_clean = synthetic.dropna() + + if len(real_clean) == 0 or len(synthetic_clean) == 0: + return 0.0 + + # Convert datetime/timedelta to numeric values if necessary. + if np.issubdtype(real_clean.dtype, np.datetime64): + # Convert to seconds since epoch + real_clean = real_clean.astype('int64') / 1e9 + synthetic_clean = synthetic_clean.astype('int64') / 1e9 + elif np.issubdtype(real_clean.dtype, np.timedelta64): + # Convert to total seconds + if hasattr(real_clean, 'dt'): + real_clean = real_clean.dt.total_seconds() + synthetic_clean = synthetic_clean.dt.total_seconds() + else: + real_clean = real_clean.astype('int64') / 1e9 + synthetic_clean = synthetic_clean.astype('int64') / 1e9 + + all_data = pd.concat([real_clean, synthetic_clean]) + bin_edges = np.histogram_bin_edges(all_data, bins=bins) + real_hist, _ = np.histogram(real_clean, bins=bin_edges, density=True) + synth_hist, _ = np.histogram(synthetic_clean, bins=bin_edges, density=True) + + # Normalize the histograms + real_hist = real_hist / np.sum(real_hist) + synth_hist = synth_hist / np.sum(synth_hist) + + tv_distance = 0.5 * np.sum(np.abs(real_hist - synth_hist)) + return 1 - tv_distance + + +# ------------------------------------------------------------------------------ +# Statistical Similarity Metrics +# ------------------------------------------------------------------------------ + +def statistic_similarity(real: pd.Series, synthetic: pd.Series) -> float: + """ + Compare basic statistics (mean, standard deviation, and median) of the real and + synthetic data and return an average similarity score between 0 and 1 (1 means perfect similarity). + + If the data is datetime or timedelta, it is converted to a numeric representation (seconds). + + Args: + real (pd.Series): Real data. + synthetic (pd.Series): Synthetic data. + + Returns: + float: Similarity score between 0 and 1. + """ + real_clean = real.dropna() + synthetic_clean = synthetic.dropna() + if len(real_clean) == 0 or len(synthetic_clean) == 0: + return 0.0 + + eps = 1e-8 # small constant to avoid division by zero + + # Convert datetime/timedelta to numeric values (in seconds) + if np.issubdtype(real_clean.dtype, np.datetime64): + real_vals = real_clean.astype('int64') / 1e9 + synth_vals = synthetic_clean.astype('int64') / 1e9 + elif np.issubdtype(real_clean.dtype, np.timedelta64): + # Use the .dt accessor if available + if hasattr(real_clean, 'dt'): + real_vals = real_clean.dt.total_seconds() + synth_vals = synthetic_clean.dt.total_seconds() + else: + real_vals = real_clean.astype('int64') / 1e9 + synth_vals = synthetic_clean.astype('int64') / 1e9 + else: + real_vals = real_clean + synth_vals = synthetic_clean + + stats = ['mean', 'std', 'median'] + real_stats = { + 'mean': real_vals.mean(), + 'std': real_vals.std(), + 'median': real_vals.median() + } + synth_stats = { + 'mean': synth_vals.mean(), + 'std': synth_vals.std(), + 'median': synth_vals.median() + } + + similarities = [] + for stat in stats: + diff = abs(real_stats[stat] - synth_stats[stat]) + denom = abs(real_stats[stat]) + eps + sim = 1 - (diff / denom) + sim = max(0, min(1, sim)) + similarities.append(sim) + return np.mean(similarities) + + + +def missing_value_similarity(real: pd.Series, synthetic: pd.Series) -> float: + """ + Compare the proportion of missing values (NaNs) in the real and synthetic data. + + Args: + real (pd.Series): Real data. + synthetic (pd.Series): Synthetic data. + + Returns: + float: 1 minus the absolute difference in missing value proportions (ranges from 0 to 1). + """ + real_missing = real.isna().mean() + synth_missing = synthetic.isna().mean() + return 1 - abs(real_missing - synth_missing) + diff --git a/synthpop/processor/__init__.py b/synthpop/processor/__init__.py index 3ef0883..b486b97 100644 --- a/synthpop/processor/__init__.py +++ b/synthpop/processor/__init__.py @@ -1,2 +1,4 @@ -from synthpop.processor.processor import Processor -from synthpop.processor.processor import NAN_KEY, NUMTOCAT_KEY +from synthpop.processor.data_processor import DataProcessor +from synthpop.processor.missing_data_handler import MissingDataHandler + +__all__ = ['DataProcessor', 'MissingDataHandler'] diff --git a/synthpop/processor/data_processor b/synthpop/processor/data_processor.py similarity index 93% rename from synthpop/processor/data_processor rename to synthpop/processor/data_processor.py index 73f3c3e..34e5a39 100644 --- a/synthpop/processor/data_processor +++ b/synthpop/processor/data_processor.py @@ -16,7 +16,6 @@ class DataProcessor: Handles: - Type conversions (categorical ↔ numerical). - - Missing value handling. - Feature transformations for Gaussian Copula. - Reverse transformations to restore original data types. """ @@ -49,7 +48,7 @@ def preprocess(self, data: pd.DataFrame) -> pd.DataFrame: return processed_data def _preprocess(self, data: pd.DataFrame) -> pd.DataFrame: - """Handles encoding, scaling, and missing values.""" + """Handles encoding, scaling.""" data = data.copy() for col, dtype in self.metadata.items(): @@ -63,7 +62,6 @@ def _preprocess(self, data: pd.DataFrame) -> pd.DataFrame: elif dtype == "numerical": scaler = StandardScaler() - data[col] = self._handle_missing_values(data[col]) data[col] = scaler.fit_transform(data[[col]]) self.scalers[col] = scaler @@ -71,7 +69,10 @@ def _preprocess(self, data: pd.DataFrame) -> pd.DataFrame: data[col] = data[col].astype(int) # Convert True/False to 1/0 elif dtype == "datetime": - data[col] = pd.to_datetime(data[col]).astype(int) // 10**9 # Convert to Unix timestamp + data[col] = data[col].apply(lambda x: x.timestamp() if pd.notnull(x) else np.nan) # Convert to Unix timestamp + + elif dtype == "timedelta": + data[col] = pd.to_timedelta(data[col]).dt.total_seconds() return data @@ -94,6 +95,9 @@ def postprocess(self, synthetic_data: pd.DataFrame) -> pd.DataFrame: elif dtype == "datetime": synthetic_data[col] = pd.to_datetime(synthetic_data[col], unit='s') + elif dtype == "timedelta": + synthetic_data[col] = pd.to_timedelta(synthetic_data[col], unit='s') + return synthetic_data[self.original_columns] # Restore original column order def validate(self, data: pd.DataFrame): diff --git a/synthpop/processor/missing_data_handler.py b/synthpop/processor/missing_data_handler.py index a1f5daa..1f03885 100644 --- a/synthpop/processor/missing_data_handler.py +++ b/synthpop/processor/missing_data_handler.py @@ -1,95 +1,277 @@ import numpy as np import pandas as pd import scipy.stats as stats -from sklearn.impute import SimpleImputer +from sklearn.experimental import enable_iterative_imputer # For MICE and EM +from sklearn.impute import SimpleImputer, IterativeImputer from sklearn.linear_model import LogisticRegression from sklearn.preprocessing import LabelEncoder -from fancyimpute import IterativeImputer # For MICE and EM import warnings + class MissingDataHandler: """Detects missingness type (MCAR, MAR, MNAR) and applies automatic imputation.""" def __init__(self): self.imputers = {} - def detect_missingness(self, df: pd.DataFrame) -> dict: - """Detects missingness type for each column. + @staticmethod + def get_column_dtypes(data) -> dict: + """ + Returns a dictionary mapping column names to abstract data types + that are compatible with the processor. + + The mapping is as follows: + - float64, float32, int64, int32 -> "numerical" + - bool -> "boolean" + - datetime64[...] -> "datetime" + - timedelta64[...] -> "timedelta" + - All others (e.g., object) -> "categorical" + """ + def map_dtype(dtype: str) -> str: + if dtype in ['float64', 'float32', 'int64', 'int32']: + return "numerical" + elif dtype == 'bool': + return "boolean" + elif 'datetime' in dtype: + return "datetime" + elif 'timedelta' in dtype: + return "timedelta" + else: + return "categorical" + + if isinstance(data, pd.DataFrame): + return {col: map_dtype(str(dtype)) for col, dtype in data.dtypes.items()} + elif isinstance(data, np.ndarray) and data.dtype.names is not None: + return {name: map_dtype(str(data.dtype.fields[name][0])) for name in data.dtype.names} + else: + raise TypeError("Data must be a pandas DataFrame or a structured numpy array.") + + def encode_predictors( + self, df: pd.DataFrame, drop_cols: list = None + ) -> pd.DataFrame: + """ + Encodes all columns in the DataFrame so that they are numeric. + Optionally, drops specified columns (e.g., the target column). + + Steps: + 1. Extract numeric columns. + 2. Convert datetime columns to Unix timestamp (numeric). + 3. Convert timedelta columns to total seconds as float. + 4. For categorical columns (object, category), create dummy variables. + 5. For boolean columns, convert to int (0/1). + 6. Concatenate everything and fill any remaining NaNs with each column's median. Args: - df (pd.DataFrame): The input DataFrame. + df (pd.DataFrame): Input DataFrame. + drop_cols (list): List of column names to drop (optional). Returns: - dict: Dictionary mapping column names to detected missingness type. + pd.DataFrame: DataFrame with only numeric values and no missing entries. """ - missingness = {} + df_work = df.copy() + if drop_cols is not None: + df_work = df_work.drop(columns=drop_cols) + + # 1. Extract numeric columns. + num_df = df_work.select_dtypes(include=[np.number], exclude = ["timedelta64[ns]"]).copy() + + # 2. Convert datetime columns to Unix timestamp (numeric). + datetime_cols = df_work.select_dtypes(include=["datetime64[ns]"]) + if not datetime_cols.empty: + datetime_numeric = datetime_cols.apply( + lambda col: col.astype(np.int64) // 10**9 + ) + num_df = pd.concat([num_df, datetime_numeric], axis=1) + + # 3. Convert timedelta columns to total seconds (as float). + timedelta_cols = df_work.select_dtypes(include=["timedelta64[ns]"]) + if not timedelta_cols.empty: + timedelta_numeric = pd.DataFrame({ + col: timedelta_cols[col].dt.total_seconds() for col in timedelta_cols.columns + }, index=df_work.index) + num_df = pd.concat([num_df, timedelta_numeric], axis=1) + + # 4. Encode categorical columns using get_dummies. + cat_df = df_work.select_dtypes(include=["object", "category"]) + if not cat_df.empty: + dummies = pd.get_dummies(cat_df, drop_first=True) + else: + dummies = pd.DataFrame(index=df_work.index) + + # 5. Handle boolean columns: convert them to int explicitly. + bool_df = df_work.select_dtypes(include=["bool"]).astype(int) + + # 6. Concatenate all predictors and fill any remaining missing values with the median. + result_df = pd.concat([num_df, dummies, bool_df], axis=1) + result_df = result_df.apply(lambda col: col.fillna(0), axis=0) + return result_df + + def detect_missingness(self, dfc: pd.DataFrame) -> dict: + """Detects missingness type for each column, handling multiple data types.""" + df = dfc.copy() + missingness = {} for col in df.columns: missing_values = df[col].isna().sum() if missing_values == 0: continue # No missing values → Skip detection + col_type = df[col].dtype + + # **Categorical Data Handling (object, category)** + if col_type == "object" or df[col].nunique() < 10: + observed_counts = df[col].dropna().value_counts() + if len(observed_counts) > 1: + _, p_value = stats.chisquare(observed_counts) + if p_value > 0.05: + missingness[col] = "MCAR" + continue - # 1️⃣ Little's MCAR Test - _, p_value = stats.chisquare(df[col].dropna().value_counts()) - if p_value > 0.05: - missingness[col] = "MCAR" + missing_mask = df[col].isna().astype(int) + # Use our helper to encode all predictors (drop the target col) + encoded_data = self.encode_predictors(df, drop_cols=[col]) + model = LogisticRegression() + model.fit(encoded_data, missing_mask) + if model.score(encoded_data, missing_mask) > 0.6: + missingness[col] = "MAR" + continue + missingness[col] = "MNAR" continue - # 2️⃣ Logistic Regression (MAR Detection) - missing_mask = df[col].isna().astype(int) - observed_data = df.drop(columns=[col]).fillna(df.mean()) - - model = LogisticRegression() - model.fit(observed_data, missing_mask) - if model.score(observed_data, missing_mask) > 0.6: # Predictable missingness → MAR + # **Numerical Data Handling (int, float)** + elif np.issubdtype(col_type, np.number): + _, p_value = stats.shapiro(df[col].dropna()) + if p_value > 0.05: + missingness[col] = "MCAR" + continue + missing_mask = df[col].isna().astype(int) + observed_data = self.encode_predictors(df, drop_cols=[col]) + model = LogisticRegression() + model.fit(observed_data, missing_mask) + if model.score(observed_data, missing_mask) > 0.6: + missingness[col] = "MAR" + continue + observed_values = df[col].dropna() + missing_rows = df[col].isna() + if missing_rows.sum() > 0: + encoded_missing_vals = self.encode_predictors(df.loc[missing_rows, df.columns != col]) + missing_vals = encoded_missing_vals.mean(axis=1) + _, p_value = stats.ks_2samp(observed_values, missing_vals) + if p_value < 0.05: + missingness[col] = "MNAR" + continue missingness[col] = "MAR" continue - # 3️⃣ Distributional Check (MNAR Detection) - observed_values = df[col].dropna() - missing_rows = df[col].isna() - if missing_rows.sum() > 0: - missing_values = df.loc[missing_rows, df.columns != col].mean(axis=1) - _, p_value = stats.ks_2samp(observed_values, missing_values) - if p_value < 0.05: - missingness[col] = "MNAR" + # **Boolean Data Handling (bool)** + elif np.issubdtype(col_type, np.bool_): + bool_as_int = df[col].astype(float) + _, p_value = stats.chisquare(bool_as_int.value_counts()) + if p_value > 0.05: + missingness[col] = "MCAR" + continue + missingness[col] = "MNAR" + continue + + # **Datetime Handling (datetime64)** + elif np.issubdtype(col_type, np.datetime64): + timestamps = df[col].dropna().astype(int) // 10**9 + _, p_value = stats.shapiro(timestamps) + if p_value > 0.05: + missingness[col] = "MCAR" + continue + missing_mask = df[col].isna().astype(int) + observed_data = self.encode_predictors(df, drop_cols=[col]) + model = LogisticRegression() + model.fit(observed_data, missing_mask) + if model.score(observed_data, missing_mask) > 0.6: + missingness[col] = "MAR" continue + missingness[col] = "MNAR" + continue - missingness[col] = "MAR" # Default to MAR if uncertain + # **Timedelta Handling (timedelta64)** + elif np.issubdtype(col_type, np.timedelta64): + durations = df[col].dropna().dt.total_seconds() + _, p_value = stats.shapiro(durations) + if p_value > 0.05: + missingness[col] = "MCAR" + continue + missingness[col] = "MNAR" + continue return missingness def apply_imputation(self, df: pd.DataFrame, missingness: dict) -> pd.DataFrame: - """Automatically applies imputation based on missingness type. - - Args: - df (pd.DataFrame): Input data with missing values. - missingness (dict): Mapping of column names to missingness type. - - Returns: - pd.DataFrame: Data with imputed values. - """ + """Automatically applies imputation based on missingness type and column data type.""" df = df.copy() - for col, mtype in missingness.items(): - if df[col].dtype == "object": - # Categorical Data + if df[col].isna().sum() == 0: + continue + + # --- Categorical Data (object, category or few unique values) --- + if ( + pd.api.types.is_object_dtype(df[col]) + or pd.api.types.is_categorical_dtype(df[col]) + or (df[col].nunique() < 10) + ): if mtype == "MCAR": - df[col].fillna(df[col].mode()[0], inplace=True) # Mode Imputation + df[col].fillna(df[col].mode()[0], inplace=True) elif mtype == "MAR": - encoder = LabelEncoder() - df[col] = encoder.fit_transform(df[col].astype(str)) - df[col] = IterativeImputer().fit_transform(df[[col]]) # Classification-based + # Use get_dummies encoding for categorical data + dummies = pd.get_dummies(df[col], prefix=col, dummy_na=True) + imputer = IterativeImputer(random_state=42) + imputed = imputer.fit_transform(dummies) + imputed_rounded = np.rint(imputed).astype(int) + imputed_df = pd.DataFrame( + imputed_rounded, columns=dummies.columns, index=df.index + ) + # Convert back to a single categorical column by taking the column with the maximum value. + predicted_category = imputed_df.idxmax(axis=1) + df[col] = predicted_category.str.split(f"{col}_").str[-1] elif mtype == "MNAR": - df[col].fillna("Missing", inplace=True) # Add "Missing" Category + df[col].fillna("Missing", inplace=True) - else: - # Numerical Data + # --- Numerical Data --- + elif pd.api.types.is_numeric_dtype(df[col]): if mtype == "MCAR": - df[col] = SimpleImputer(strategy="mean").fit_transform(df[[col]]) - elif mtype == "MAR": - df[col] = IterativeImputer().fit_transform(df[[col]]) # Regression-based - elif mtype == "MNAR": - df[col] = IterativeImputer().fit_transform(df[[col]]) # EM Algorithm + imputer = SimpleImputer(strategy="mean") + df[col] = imputer.fit_transform(df[[col]]).ravel() + elif mtype in ["MAR", "MNAR"]: + imputer = IterativeImputer(random_state=42) + df[col] = imputer.fit_transform(df[[col]]).ravel() + # --- Boolean Data --- + elif pd.api.types.is_bool_dtype(df[col]): + if mtype == "MCAR": + df[col].fillna(df[col].mode()[0], inplace=True) + elif mtype in ["MAR", "MNAR"]: + numeric_vals = df[col].astype(float) + imputer = IterativeImputer(random_state=42) + imputed = imputer.fit_transform(numeric_vals.values.reshape(-1, 1)) + df[col] = np.rint(imputed).astype(bool).flatten() + + # --- Datetime Data --- + elif pd.api.types.is_datetime64_any_dtype(df[col]): + print("entering here") + numeric_series = df[col].apply(lambda x: x.timestamp() if pd.notnull(x) else np.nan) + if mtype == "MCAR": + imputer = SimpleImputer(strategy="median") + elif mtype in ["MAR", "MNAR"]: + imputer = IterativeImputer(random_state=42) + imputed_numeric = imputer.fit_transform( + numeric_series.values.reshape(-1, 1) + ) + df[col] = pd.to_datetime(imputed_numeric.flatten(), unit='s') + + # --- Timedelta Data --- + elif pd.api.types.is_timedelta64_dtype(df[col]): + numeric_series = df[col].apply(lambda x: x.total_seconds() if pd.notnull(x) else np.nan).values.reshape(-1, 1) + if mtype == "MCAR": + imputer = SimpleImputer(strategy="median" ) + elif mtype in ["MAR", "MNAR"]: + imputer = IterativeImputer(random_state=42) + imputed_numeric = imputer.fit_transform(numeric_series) + df[col] = pd.to_timedelta(imputed_numeric.flatten(), unit="s") + else: + df[col].fillna(df[col].mode()[0], inplace=True) return df diff --git a/synthpop/synthpop.py b/synthpop/synthpop.py deleted file mode 100644 index 03a4051..0000000 --- a/synthpop/synthpop.py +++ /dev/null @@ -1,203 +0,0 @@ -import numpy as np -import pandas as pd - -# classes -from synthpop.validator import Validator -from synthpop.processor import Processor -# global variables -from synthpop import NUM_COLS_DTYPES -from synthpop.processor import NAN_KEY -from synthpop.method import CART_METHOD, GC_METHOD, METHODS_MAP, NA_METHODS - - -class Synthpop: - def __init__(self, - method=None, - visit_sequence=None, - # predictor_matrix=None, - proper=False, - cont_na=None, - smoothing=False, - default_method=CART_METHOD, - numtocat=None, - catgroups=None, - seed=None): - # initialise the validator and processor - self.validator = Validator(self) - self.processor = Processor(self) - - # initialise arguments - self.method = method - self.visit_sequence = visit_sequence - self.predictor_matrix = None - self.proper = proper - self.cont_na = cont_na - self.smoothing = smoothing - self.default_method = default_method - self.numtocat = numtocat - self.catgroups = catgroups - self.seed = seed - self.map_column_to_NaN_column = {} - # check init - self.validator.check_init() - - def include_nan_columns(self): - for (col,nan_col) in self.map_column_to_NaN_column.items(): - if col not in self.visit_sequence: - continue - - index_of_col = self.visit_sequence.index(col) - self.visit_sequence.insert(index_of_col,nan_col) - - def pre_preprocess(self,df,dtypes,nan_fill): - for column in df: - if dtypes[column] != 'float': - continue - maybe_nans = df[column].isnull() - if not maybe_nans.any(): - continue - - df.loc[maybe_nans,column] = nan_fill - - nan_col_name = column+"_NaN" - df.loc[:,nan_col_name] = maybe_nans - self.map_column_to_NaN_column[column] = nan_col_name - - dtypes[nan_col_name] = 'category' - - return df,dtypes - - def post_postprocessing(self,syn_df): - for column in syn_df: - if column in self.map_column_to_NaN_column.keys(): - nan_col_name = self.map_column_to_NaN_column[column] - column_NaN_at = syn_df[nan_col_name] - syn_df.loc[column_NaN_at,column] = None - syn_df = syn_df.drop(columns=nan_col_name) - - return syn_df - - def _infer_dtypes(self, df): - """Automatically infer data types from DataFrame. - - Args: - df: pandas DataFrame - - Returns: - dict: Mapping of column names to inferred types ('int', 'float', 'datetime', 'category', 'bool') - """ - dtypes = {} - for column in df.columns: - pd_dtype = str(df[column].dtype) - - if pd_dtype.startswith('int'): - dtypes[column] = 'int' - elif pd_dtype.startswith('float'): - dtypes[column] = 'float' - elif pd_dtype.startswith('datetime'): - dtypes[column] = 'datetime' - elif pd_dtype.startswith('bool'): - dtypes[column] = 'bool' - else: - # For object or string dtypes, check if it should be categorical - dtypes[column] = 'category' - - return dtypes - - def fit(self, df, dtypes=None): - """Fit the synthetic data generator. - - Args: - df: pandas DataFrame to learn from - dtypes: Optional dict mapping column names to types. If not provided, types will be inferred. - """ - # Infer dtypes if not provided - if dtypes is None: - dtypes = self._infer_dtypes(df) - - # Validate DataFrame - if not df.columns.is_unique: - raise ValueError("DataFrame column names must be unique") - - df,dtypes = self.pre_preprocess(df,dtypes,-8) - - self.df_columns = df.columns.tolist() - # Only set visit_sequence if not provided in init - if self.visit_sequence is None: - self.visit_sequence = df.columns.tolist() - elif isinstance(self.visit_sequence, list) and all(isinstance(x, int) for x in self.visit_sequence): - # Convert numeric indices to column names - self.visit_sequence = [df.columns[i] for i in self.visit_sequence] - - self.include_nan_columns() - self.n_df_rows, self.n_df_columns = np.shape(df) - self.df_dtypes = dtypes - - # check processor - self.validator.check_processor() - # preprocess - - #processor.preprocess has side effects on the processor object and on this (self) object - #processor.processing_dict[NAN_KEY][col] - #spop.df_dtypes[col_nan_name] - processed_df = self.processor.preprocess(df, self.df_dtypes) - print(processed_df) - self.processed_df_columns = processed_df.columns.tolist() - self.n_processed_df_columns = len(self.processed_df_columns) - - # check fit - self.validator.check_fit() - # fit - self._fit(processed_df) - - def _fit(self, df): - self.saved_methods = {} - - # train - self.predictor_matrix_columns = self.predictor_matrix.columns.to_numpy() - for col, visit_step in self.visit_sequence.sort_values().items(): - print('train_{}'.format(col)) - - # initialise the method - col_method = METHODS_MAP[self.method[col]](dtype=self.df_dtypes[col], smoothing=self.smoothing[col], proper=self.proper, random_state=self.seed) - # fit the method - col_predictors = self.predictor_matrix_columns[self.predictor_matrix.loc[col].to_numpy() == 1] - col_method.fit(X_df=df[col_predictors], y_df=df[col]) - # save the method - self.saved_methods[col] = col_method - - def generate(self, k=None): - self.k = k - - # check generate - self.validator.check_generate() - # generate - synth_df = self._generate() - # postprocess - processed_synth_df = self.processor.postprocess(synth_df) - - return self.post_postprocessing(processed_synth_df) - - def _generate(self): - # Only generate columns that were in the visit sequence - synth_df = pd.DataFrame(data=np.zeros([self.k, len(self.visit_sequence)]), columns=self.visit_sequence.index) - - for col, visit_step in self.visit_sequence.sort_values().items(): - print('generate_{}'.format(col)) - - # reload the method - col_method = self.saved_methods[col] - # predict with the method - col_predictors = self.predictor_matrix_columns[self.predictor_matrix.loc[col].to_numpy() == 1] - synth_df[col] = col_method.predict(synth_df[col_predictors]) - - # change all missing values to 0 - if col in self.processor.processing_dict[NAN_KEY] and self.df_dtypes[col] in NUM_COLS_DTYPES and self.method[col] in NA_METHODS: - nan_indices = synth_df[self.processor.processing_dict[NAN_KEY][col]['col_nan_name']] != 0 - synth_df.loc[nan_indices, col] = 0 - - # map dtype to original dtype (only excpetion if column is full of NaNs) - if synth_df[col].notna().any(): - synth_df[col] = synth_df[col].astype(self.df_dtypes[col]) - - return synth_df \ No newline at end of file diff --git a/synthpop/validator/__init__.py b/synthpop/validator/__init__.py index 3143690..d55577d 100644 --- a/synthpop/validator/__init__.py +++ b/synthpop/validator/__init__.py @@ -1 +1,5 @@ -from synthpop.validator.validator import Validator +from .validator import Validator + +__all__ = [ + "Validator", +] \ No newline at end of file diff --git a/synthpop/validator/validator.py b/synthpop/validator/validator.py index aa71005..f54852f 100644 --- a/synthpop/validator/validator.py +++ b/synthpop/validator/validator.py @@ -1,322 +1,5 @@ -import numpy as np -import pandas as pd - -# global variables -from synthpop import NUM_COLS_DTYPES -from synthpop.method import EMPTY_METHOD, SAMPLE_METHOD -from synthpop.method import DEFAULT_METHODS_MAP, INIT_METHODS_MAP, CONT_TO_CAT_METHODS_MAP -from synthpop.method import ALL_METHODS, INIT_METHODS, DEFAULT_METHODS, NA_METHODS -from synthpop.processor import NAN_KEY - - -INIT_STEP = 'init' -PROCESSOR_STEP = 'processor' -FIT_STEP = 'fit' -GENERATE_STEP = 'generate' - -NONE_TYPE = type(None) - -DENSITY = 'density' class Validator: - def __init__(self, spop): - self.spop = spop - self.attributes_types = {'method': (NONE_TYPE, str, list), - 'visit_sequence': (NONE_TYPE, np.ndarray, list), - # 'predictor_matrix': (NONE_TYPE,), - 'proper': (bool,), - 'cont_na': (NONE_TYPE, dict), - 'smoothing': (bool, str, dict), - 'default_method': (str,), - 'numtocat': (NONE_TYPE, list), - 'catgroups': (NONE_TYPE, int, dict), - 'seed': (NONE_TYPE, int), - 'k': (NONE_TYPE, int)} - - def check_init(self): - step = INIT_STEP - - self.default_method_validator(step=step) - self.method_validator(step=step) - self.visit_sequence_validator(step=step) - self.predictor_matrix_validator(step=step) - self.proper_validator(step=step) - self.cont_na_validator(step=step) - self.smoothing_validator(step=step) - self.numtocat_validator(step=step) - self.catgroups_validator(step=step) - self.seed_validator(step=step) - - def check_processor(self): - step = PROCESSOR_STEP - - self.visit_sequence_validator(step=step) - self.method_validator(step=step) - self.predictor_matrix_validator(step=step) - self.smoothing_validator(step=step) - - self.cont_na_validator(step=step) - self.numtocat_validator(step=step) - self.catgroups_validator(step=step) - - def check_fit(self): - step = FIT_STEP - - self.method_validator(step=step) - self.visit_sequence_validator(step=step) - self.predictor_matrix_validator(step=step) - self.smoothing_validator(step=step) - - def check_generate(self): - step = GENERATE_STEP - - self.k_validator(step=step) - - def check_valid_type(self, attribute_name, return_type=False): - attribute_type = getattr(self.spop, attribute_name) - expected_types = self.attributes_types[attribute_name] - assert isinstance(attribute_type, expected_types) - - if return_type: - return attribute_type - - def method_validator(self, step=None): - if step == INIT_STEP: - # validate method type is allowed - method_type = self.check_valid_type('method', return_type=True) - print(method_type) - - if isinstance(method_type, str): - # if method type is str - # validate method is in allowed init methods - print(method_type) - assert self.spop.method in INIT_METHODS - - elif isinstance(method_type, list): - # if method type is list - # validate all methods are allowed - assert all(m in ALL_METHODS for m in self.spop.method) - - if step == PROCESSOR_STEP: - first_visited_col = self.spop.visit_sequence.index[self.spop.visit_sequence == 0].values[0] - - if self.spop.method is None: - # if method is not specified - # for each column set method to default method according to its dtype (method for first visited column is sample_method) - self.spop.method = [DEFAULT_METHODS_MAP[self.spop.default_method][self.spop.df_dtypes[col]] if col != first_visited_col else SAMPLE_METHOD - for col in self.spop.df_columns] - - elif isinstance(self.spop.method, str): - # if method type is str - # for each column set method to the corresponding allowed method according to its dtype (method for first visited column is sample_method) - self.spop.method = [INIT_METHODS_MAP[self.spop.method][self.spop.df_dtypes[col]] if col != first_visited_col else SAMPLE_METHOD - for col in self.spop.df_columns] - - else: - # validate method for first visited column with non empty method is sample_method - for col, visit_order in self.spop.visit_sequence.sort_values().items(): - col_method = self.spop.method[self.spop.df_columns.index(col)] - if col_method != EMPTY_METHOD: - assert col_method == SAMPLE_METHOD - break - # assert all(self.spop.method[i] == SAMPLE_METHOD for i, col in enumerate(self.spop.df_columns) if col == first_visited_col) - - # validate all columns have specified methods - assert len(self.spop.method) == self.spop.n_df_columns - self.spop.method = pd.Series(self.spop.method, index=self.spop.df_columns) - - if step == FIT_STEP: - for col in self.spop.method.index: - if col in self.spop.numtocat: - self.spop.method[col] = CONT_TO_CAT_METHODS_MAP[self.spop.method[col]] - - elif col in self.spop.processor.processing_dict[NAN_KEY] and self.spop.df_dtypes[col] in NUM_COLS_DTYPES and self.spop.method[col] in NA_METHODS: - # TODO put in a function - nan_col_index = self.spop.method.index.get_loc(col) - index_list = self.spop.method.index.tolist() - index_list.insert(nan_col_index, self.spop.processed_df_columns[nan_col_index]) - self.spop.method = self.spop.method.reindex(index_list, fill_value=CONT_TO_CAT_METHODS_MAP[self.spop.method[col]]) - - def visit_sequence_validator(self, step=None): - if step == INIT_STEP: - print('A') - # validate visit_sequence type is allowed - visit_sequence_type = self.check_valid_type('visit_sequence', return_type=True) - - if isinstance(visit_sequence_type, np.ndarray): - # if visit_sequence type is numpy array - # transform visit_sequence into a list - self.spop.visit_sequence = [col.item() for col in self.spop.visit_sequence] - visit_sequence_type = list - - if isinstance(visit_sequence_type, list): - # if visit_sequence type is list - # validate all visits are unique - assert len(set(self.spop.visit_sequence)) == len(self.spop.visit_sequence) - # validate all visits are either type int or type str - assert all(isinstance(col, int) for col in self.spop.visit_sequence) or all(isinstance(col, str) for col in self.spop.visit_sequence) - - if step == PROCESSOR_STEP: - print('TestX') - if self.spop.visit_sequence is None: - # if visit_sequence is not specified - # visit all columns in a row - self.spop.visit_sequence = [col.item() for col in np.arange(self.spop.n_df_columns)] - - if isinstance(self.spop.visit_sequence[0], int): - # if visit_sequence is list of column indices - # validate every index in visit_sequence is a valid column index - assert set(self.spop.visit_sequence).issubset(set(np.arange(self.spop.n_df_columns))) - # transform visit_sequence into a list of column names - self.spop.visit_sequence = [self.spop.df_columns[i] for i in self.spop.visit_sequence] - else: - # validate every column name in visit_sequence is a valid column name - assert set(self.spop.visit_sequence).issubset(set(self.spop.df_columns)) - - self.spop.visited_columns = [col for col in self.spop.df_columns if col in self.spop.visit_sequence] - self.spop.visit_sequence = pd.Series([self.spop.visit_sequence.index(col) for col in self.spop.visited_columns], index=self.spop.visited_columns) - - if step == FIT_STEP: - for col in self.spop.visit_sequence.index: - if col in self.spop.processor.processing_dict[NAN_KEY] and self.spop.df_dtypes[col] in NUM_COLS_DTYPES and self.spop.method[col] in NA_METHODS: - visit_step = self.spop.visit_sequence[col] - self.spop.visit_sequence.loc[self.spop.visit_sequence >= visit_step] += 1 - - nan_col_index = self.spop.visit_sequence.index.get_loc(col) - index_list = self.spop.visit_sequence.index.tolist() - index_list.insert(nan_col_index, self.spop.processed_df_columns[nan_col_index]) - self.spop.visit_sequence = self.spop.visit_sequence.reindex(index_list, fill_value=visit_step) - - def predictor_matrix_validator(self, step=None): - # if step == INIT_STEP: - # # validate predictor_matrix type is allowed - # self.check_valid_type('predictor_matrix') - - if step == PROCESSOR_STEP: - # build predictor_matrix so all previously visited columns are used for the prediction of the currently visited - self.spop.predictor_matrix = np.zeros([len(self.spop.visit_sequence), len(self.spop.visit_sequence)], dtype=int) - self.spop.predictor_matrix = pd.DataFrame(self.spop.predictor_matrix, index=self.spop.visit_sequence.index, columns=self.spop.visit_sequence.index) - visited_columns = [] - for col, _ in self.spop.visit_sequence.sort_values().items(): - self.spop.predictor_matrix.loc[col, visited_columns] = 1 - visited_columns.append(col) - - if step == FIT_STEP: - for col in self.spop.predictor_matrix: - if col in self.spop.processor.processing_dict[NAN_KEY] and self.spop.df_dtypes[col] in NUM_COLS_DTYPES and self.spop.method[col] in NA_METHODS: - nan_col_index = self.spop.predictor_matrix.columns.get_loc(col) - self.spop.predictor_matrix.insert(nan_col_index, self.spop.processed_df_columns[nan_col_index], self.spop.predictor_matrix[col]) - - index_list = self.spop.predictor_matrix.index.tolist() - index_list.insert(nan_col_index, self.spop.processed_df_columns[nan_col_index]) - self.spop.predictor_matrix = self.spop.predictor_matrix.reindex(index_list, fill_value=0) - self.spop.predictor_matrix.loc[self.spop.processed_df_columns[nan_col_index]] = self.spop.predictor_matrix.loc[col] - - self.spop.predictor_matrix.loc[col, self.spop.processed_df_columns[nan_col_index]] = 1 - - def proper_validator(self, step=None): - if step == INIT_STEP: - # validate proper type is allowed - self.check_valid_type('proper') - - def cont_na_validator(self, step=None): - if step == INIT_STEP: - # validate cont_na type is allowed - self.check_valid_type('cont_na') - - if step == PROCESSOR_STEP: - if self.spop.cont_na is None: - self.spop.cont_na = {} - else: - # validate columns in cont_na are valid columns - assert all(col in self.spop.df_columns for col in self.spop.cont_na) - # assert all(col in self.spop.visited_columns for col in self.spop.cont_na) - # validate the type of columns in cont_na are valid types - assert all(self.spop.df_dtypes[col] in NUM_COLS_DTYPES for col in self.spop.cont_na) - self.spop.cont_na = {col: col_cont_na for col, col_cont_na in self.spop.cont_na.items() if self.spop.method[col] in NA_METHODS} - - def smoothing_validator(self, step=None): - if step == INIT_STEP: - # validate smoothing type is allowed - self.check_valid_type('smoothing') - - if step == PROCESSOR_STEP: - if self.spop.smoothing is False: - self.spop.smoothing = {col: False for col in self.spop.df_columns} - elif isinstance(self.spop.smoothing, str): - # if smoothing type is str - # validate smoothing is 'density' - assert self.spop.smoothing == DENSITY - self.spop.smoothing = {col: self.spop.df_dtypes[col] in NUM_COLS_DTYPES for col in self.spop.df_columns} - else: - # validate smoothing is 'denisty' for some/all numerical columns and False for all other columns - assert all((smoothing_method == DENSITY and self.spop.df_dtypes[col] in NUM_COLS_DTYPES) or smoothing_method is False - for col, smoothing_method in self.spop.smoothing.items()) - self.spop.smoothing = {col: (self. spop.smoothing.get(col, False) == DENSITY and self.spop.df_dtypes[col] in NUM_COLS_DTYPES) for col in self.spop.df_columns} - - if step == FIT_STEP: - for col in self.spop.processed_df_columns: - if col in self.spop.numtocat: - self.spop.smoothing[col] = False - elif col in self.spop.processor.processing_dict[NAN_KEY] and self.spop.df_dtypes[col] in NUM_COLS_DTYPES: - self.spop.smoothing[self.spop.processor.processing_dict[NAN_KEY][col]['col_nan_name']] = False - - def default_method_validator(self, step=None): - if step == INIT_STEP: - # validate default_method type is allowed - self.check_valid_type('default_method') - - # validate default_method is in allowed default methods - assert self.spop.default_method in DEFAULT_METHODS - - def numtocat_validator(self, step=None): - if step == INIT_STEP: - # validate numtocat type is allowed - self.check_valid_type('numtocat') - - if step == PROCESSOR_STEP: - if self.spop.numtocat is None: - self.spop.numtocat = [] - else: - # validate all columns in numtocat are valid columns - assert all(col in self.spop.df_columns for col in self.spop.numtocat) - # assert all(col in self.spop.visited_columns for col in self.spop.numtocat) - # validate all columns in numtocat are numerical columns - assert all(self.spop.df_dtypes[col] in NUM_COLS_DTYPES for col in self.spop.numtocat) - - def catgroups_validator(self, step=None): - if step == INIT_STEP: - # validate catgroups type is allowed - catgroups_type = self.check_valid_type('catgroups', return_type=True) - - if isinstance(catgroups_type, int): - # if catgroups type is int - # validate catgroups is more than 1 - assert self.spop.catgroups > 1 - - elif isinstance(catgroups_type, dict): - # if catgroups type is dict - # validate the keys in catgroups are the same as the columns in numtocat - assert set(self.spop.catgroups.keys()) == set(self.spop.numtocat) - # validate all values in catgroups are type int and more than 1 - assert all((isinstance(col_groups, int) and col_groups > 1) for col_groups in self.spop.catgroups.values()) - - if step == PROCESSOR_STEP: - if self.spop.catgroups is None: - self.spop.catgroups = {col: 5 for col in self.spop.numtocat} - elif isinstance(self.spop.catgroups, int): - self.spop.catgroups = {col: self.spop.catgroups for col in self.spop.numtocat} - - def seed_validator(self, step=None): - if step == INIT_STEP: - # validate seed type is allowed - self.check_valid_type('seed') - - def k_validator(self, step=None): - if step == GENERATE_STEP: - # validate k type is allowed - self.check_valid_type('k') - - if self.spop.k is None: - self.spop.k = self.spop.n_df_rows + def __init__(self) -> None: + pass \ No newline at end of file From f721344445a287dbbaf207e3ee020db4b391f460 Mon Sep 17 00:00:00 2001 From: Emmanuel Jordy Menvouta <56538317+emmanueljordy@users.noreply.github.com> Date: Mon, 3 Mar 2025 17:50:36 +0100 Subject: [PATCH 4/4] adjust unit tests --- synthpop/processor/processor.py | 122 ------------- tests/test_synthpop.py | 310 ++++++++++++++++++++++---------- tests_processing.py | 44 ----- 3 files changed, 211 insertions(+), 265 deletions(-) delete mode 100644 synthpop/processor/processor.py delete mode 100644 tests_processing.py diff --git a/synthpop/processor/processor.py b/synthpop/processor/processor.py deleted file mode 100644 index b2065c3..0000000 --- a/synthpop/processor/processor.py +++ /dev/null @@ -1,122 +0,0 @@ -import numpy as np -import pandas as pd - -# global variables -from synthpop import NUM_COLS_DTYPES, CAT_COLS_DTYPES - -NAN_KEY = 'nan' -NUMTOCAT_KEY = 'numtocat' - - -class Processor: - def __init__(self, spop): - self.spop = spop - self.processing_dict = {NUMTOCAT_KEY: {}, - NAN_KEY: {} - } - - - def preprocess(self, df, dtypes): - for col in self.spop.visited_columns: - col_nan_indices = df[col].isna() - cont_nan_indices = {v: df[col] == v for v in self.spop.cont_na.get(col, [])} - col_nan_series = [(np.nan, col_nan_indices)] + list(cont_nan_indices.items()) - - col_all_nan_indices = pd.DataFrame({index: value[1] for index, value in enumerate(col_nan_series)}).max(axis=1) - col_not_nan_indices = np.invert(col_all_nan_indices) - - # transform numerical columns in numtocat to categorical - if col in self.spop.numtocat: - self.processing_dict[NUMTOCAT_KEY][col] = {'dtype': self.spop.df_dtypes[col], - 'categories': {} - } - - # Dealing With Non-NaN Values - not_nan_values = df.loc[col_not_nan_indices, col].copy() - df.loc[col_not_nan_indices, col] = pd.cut(df.loc[col_not_nan_indices, col], self.spop.catgroups[col], labels=range(self.spop.catgroups[col]), include_lowest=True) - - grouped = pd.DataFrame({'grouped': df.loc[col_not_nan_indices, col], 'real': not_nan_values}).groupby('grouped') - self.processing_dict[NUMTOCAT_KEY][col]['categories'] = grouped['real'].apply(np.array).to_dict() - - # Dealing with NaN - for index, (_, bool_series) in enumerate(col_nan_series): - nan_cat = self.spop.catgroups[col] + index - self.processing_dict[NUMTOCAT_KEY][col]['categories'][nan_cat] = df.loc[bool_series, col].to_numpy() - df.loc[bool_series, col] = nan_cat - - df[col] = df[col].astype('category') - self.spop.df_dtypes[col] = 'category' - - else: - # NaNs in category columns - # need to process NaNs only as all other categories will be taken care automatically - if self.spop.df_dtypes[col] in CAT_COLS_DTYPES: - if col_nan_indices.any(): - # TODO beware of 'NaN_category' naming - col_nan_category = 'NaN_category' - self.processing_dict[NAN_KEY][col] = {'dtype': self.spop.df_dtypes[col], - 'nan_value': col_nan_category - } - - df[col] = df[col].cat.add_categories(col_nan_category) #argument 'inplace' is deprecated and removed - df[col].fillna(col_nan_category, inplace=True) - - # NaNs in numerical columns - elif self.spop.df_dtypes[col] in NUM_COLS_DTYPES: - if col_all_nan_indices.any(): - # insert new column in df - # TODO beware of '_NaN' naming - col_nan_name = col + '_NaN' - df.insert(df.columns.get_loc(col), col_nan_name, 0) #inserts columName_NaN in dataframe - - self.processing_dict[NAN_KEY][col] = {'col_nan_name': col_nan_name, - 'dtype': self.spop.df_dtypes[col], - 'nan_flags': {} - } - - for index, (cat, bool_series) in enumerate(col_nan_series): - cat_index = index + 1 - self.processing_dict[NAN_KEY][col]['nan_flags'][cat_index] = cat - df.loc[bool_series, col_nan_name] = cat_index - df.loc[col_all_nan_indices, col] = 0 - - df.loc[:,col_nan_name] = df[col_nan_name].astype('category') - self.spop.df_dtypes[col_nan_name] = 'category' - - return df - - def postprocess(self, synth_df): - #sex_NaN is not a column of synth_df - for col, processing_numtocat_col_dict in self.processing_dict[NUMTOCAT_KEY].items(): - synth_df[col] = synth_df[col].astype(object) - col_synth_df = synth_df[col].copy() - - for category, category_values in processing_numtocat_col_dict['categories'].items(): - category_indices = col_synth_df == category - synth_df.loc[category_indices, col] = np.random.choice(category_values, size=category_indices.sum(), replace=True) - - # cast dtype back to original (float for int column with NaNs) - if synth_df[col].isna().any() and processing_numtocat_col_dict['dtype'] == 'int': - synth_df[col] = synth_df[col].astype(float) - else: - synth_df[col] = synth_df[col].astype(processing_numtocat_col_dict['dtype']) - # self.spop.df_dtypes[col] = processing_numtocat_col_dict['dtype'] - - for col, processing_nan_col_dict in self.processing_dict[NAN_KEY].items(): - # NaNs in category columns - # need to postprocess NaNs only all other categories will be taken care automatically - if processing_nan_col_dict['dtype'] in CAT_COLS_DTYPES: - col_nan_value = processing_nan_col_dict['nan_value'] - synth_df[col] = synth_df[col].astype(object) - synth_df.loc[synth_df[col] == col_nan_value, col] = np.nan - synth_df[col] = synth_df[col].astype('category') - - # NaNs in numerical columns - #The code below sets changes NANs in numerical columns to a given value, and removes the NAN indicator column. - elif processing_nan_col_dict['dtype'] in NUM_COLS_DTYPES: - for col_nan_flag, col_nan_value in processing_nan_col_dict['nan_flags'].items(): - nan_flag_indices = synth_df[processing_nan_col_dict['col_nan_name']] == col_nan_flag #expects columnName_NAN in the synthetic data set - synth_df.loc[nan_flag_indices, col] = col_nan_value - synth_df.drop(columns=processing_nan_col_dict['col_nan_name'], inplace=True) - - return synth_df diff --git a/tests/test_synthpop.py b/tests/test_synthpop.py index 4604040..1fc12e5 100644 --- a/tests/test_synthpop.py +++ b/tests/test_synthpop.py @@ -1,103 +1,215 @@ -import pytest +# test_synthpop.py + +import unittest +import numpy as np import pandas as pd -from synthpop import Synthpop -from datasets.adult import df, dtypes +from synthpop.metrics import MetricsReport, EfficacyMetrics, DisclosureProtection +from synthpop.processor.data_processor import DataProcessor, InvalidDataError +from synthpop.processor.missing_data_handler import MissingDataHandler +from synthpop.method.GC import GaussianCopulaMethod -def test_synthpop_default_parameters(): - """Test Synthpop with default parameters and automatic type inference.""" - # Initialize Synthpop - spop = Synthpop() - - # Fit the model with automatic type inference - spop.fit(df) - - # Generate synthetic data - synth_df = spop.generate(len(df)) - - # Verify the synthetic dataframe has the same shape as original - assert synth_df.shape == df.shape - - # Verify the synthetic dataframe has the same columns as original - assert all(synth_df.columns == df.columns) - - # Verify inferred dtypes match expected types - assert spop.df_dtypes['age'] == 'int' - assert spop.df_dtypes['workclass'] == 'category' - assert spop.df_dtypes['education'] == 'category' - - # Verify the method attribute contains expected default values - assert isinstance(spop.method, pd.Series) - assert 'age' in spop.method.index - assert spop.method['age'] == 'sample' # age should use sample method - assert all(spop.method[spop.method != 'sample'] == 'cart') # rest should use cart - - # Verify visit sequence is properly set - assert isinstance(spop.visit_sequence, pd.Series) - assert len(spop.visit_sequence) == len(df.columns) - assert all(spop.visit_sequence.index == df.columns) - - # Verify predictor matrix is properly set - assert isinstance(spop.predictor_matrix, pd.DataFrame) - assert spop.predictor_matrix.shape == (len(df.columns), len(df.columns)) - assert all(spop.predictor_matrix.index == df.columns) - assert all(spop.predictor_matrix.columns == df.columns) +# ------------------------------- +# Tests for MetricsReport +# ------------------------------- +class TestMetricsReport(unittest.TestCase): + def setUp(self): + # Create sample real and synthetic data with various types. + self.real_df = pd.DataFrame({ + "numeric_col": [1, 2, 3, 4, 5, np.nan], + "categorical_col": ["a", "b", "a", "c", "b", "b"], + "datetime_col": pd.date_range("2023-01-01", periods=6), + "boolean_col": [True, False, True, False, True, False] + }) + self.synthetic_df = pd.DataFrame({ + "numeric_col": [1.1, 2.1, 3.1, 4.0, 5.2, np.nan], + "categorical_col": ["a", "b", "b", "c", "d", "b"], + "datetime_col": pd.date_range("2023-01-01", periods=6), + "boolean_col": [True, True, True, False, True, False] + }) + self.metadata = { + "numeric_col": "numerical", + "categorical_col": "categorical", + "datetime_col": "datetime", + "boolean_col": "boolean" + } + + def test_generate_report(self): + report = MetricsReport(self.real_df, self.synthetic_df, self.metadata) + report_df = report.generate_report() + self.assertIsInstance(report_df, pd.DataFrame) + expected_cols = {"column", "type", "missing_value_similarity", "range_coverage", + "boundary_adherence", "ks_complement", "tv_complement", + "statistic_similarity", "category_coverage", "category_adherence"} + self.assertTrue(expected_cols.issubset(set(report_df.columns))) + # Check that non-applicable metrics are marked as "N/A" + num_report = report_df[report_df["type"]=="numerical"].iloc[0] + self.assertEqual(num_report["category_coverage"], "N/A") + cat_report = report_df[report_df["type"]=="categorical"].iloc[0] + self.assertEqual(cat_report["range_coverage"], "N/A") -def test_synthpop_with_manual_dtypes(): - """Test Synthpop with manually specified dtypes.""" - # Initialize Synthpop - spop = Synthpop() - - # Fit the model with explicit dtypes - spop.fit(df, dtypes) - - # Verify the dtypes were set correctly - for col, dtype in dtypes.items(): - assert spop.df_dtypes[col] == dtype - - # Generate synthetic data - synth_df = spop.generate(len(df)) - - # Verify the synthetic dataframe has the same shape and columns - assert synth_df.shape == df.shape - assert all(synth_df.columns == df.columns) +# ------------------------------- +# Tests for EfficacyMetrics +# ------------------------------- +class TestEfficacyMetrics(unittest.TestCase): + def test_regression(self): + np.random.seed(42) + real_reg = pd.DataFrame({ + "feat1": np.random.normal(0, 1, 100), + "feat2": np.random.normal(5, 2, 100), + "target": np.random.normal(10, 3, 100) + }) + synthetic_reg = pd.DataFrame({ + "feat1": np.random.normal(0, 1, 100), + "feat2": np.random.normal(5, 2, 100), + "target": np.random.normal(10, 3, 100) + }) + efficacy_reg = EfficacyMetrics(task='regression', target_column="target", random_state=42) + metrics = efficacy_reg.evaluate(real_reg, synthetic_reg) + self.assertIn("mse", metrics) + self.assertIn("mae", metrics) + self.assertIn("r2", metrics) + self.assertLessEqual(metrics["r2"], 1.0) -def test_synthpop_custom_visit_sequence(): - """Test Synthpop with custom visit sequence using Adult dataset.""" - # Define custom visit sequence - visit_sequence = [0, 1, 5, 3, 2] - - # Initialize Synthpop with custom visit sequence - spop = Synthpop(visit_sequence=visit_sequence) - - # Fit the model with automatic type inference - spop.fit(df) - - # Generate synthetic data - synth_df = spop.generate(len(df)) - - # Verify only specified columns were synthesized - expected_columns = ['age', 'workclass', 'marital.status', 'education', 'fnlwgt'] - assert len(synth_df.columns) == len(expected_columns) - assert all(col in synth_df.columns for col in expected_columns) - - # Verify visit sequence matches what was specified - assert len(spop.visit_sequence) == len(visit_sequence) - assert spop.visit_sequence['age'] == 0 - assert spop.visit_sequence['workclass'] == 1 - assert spop.visit_sequence['marital.status'] == 2 - assert spop.visit_sequence['education'] == 3 - assert spop.visit_sequence['fnlwgt'] == 4 - - # Verify predictor matrix has correct shape for subset of columns - assert spop.predictor_matrix.shape == (len(expected_columns), len(expected_columns)) - assert all(col in spop.predictor_matrix.columns for col in expected_columns) - assert all(col in spop.predictor_matrix.index for col in expected_columns) - - # Verify specific predictor relationships from example - pred_matrix = spop.predictor_matrix - assert pred_matrix.loc['age', 'age'] == 0 - assert pred_matrix.loc['workclass', 'age'] == 1 - assert pred_matrix.loc['workclass', 'workclass'] == 0 - assert pred_matrix.loc['fnlwgt', ['age', 'workclass', 'education', 'marital.status']].sum() == 4 - assert pred_matrix.loc['education', ['age', 'workclass', 'marital.status']].sum() == 3 - assert pred_matrix.loc['marital.status', ['age', 'workclass']].sum() == 2 + def test_classification(self): + np.random.seed(42) + real_clf = pd.DataFrame({ + "feat1": np.random.normal(0, 1, 100), + "feat2": np.random.normal(5, 2, 100), + "target": np.random.choice(["A", "B"], size=100) + }) + synthetic_clf = pd.DataFrame({ + "feat1": np.random.normal(0, 1, 100), + "feat2": np.random.normal(5, 2, 100), + "target": np.random.choice(["A", "B"], size=100) + }) + efficacy_clf = EfficacyMetrics(task='classification', target_column="target", random_state=42) + metrics = efficacy_clf.evaluate(real_clf, synthetic_clf) + self.assertIn("accuracy", metrics) + self.assertIn("f1_score", metrics) + +# ------------------------------- +# Tests for DisclosureProtection +# ------------------------------- +class TestDisclosureProtection(unittest.TestCase): + def test_score_and_report(self): + np.random.seed(42) + real_dp = pd.DataFrame({ + "f1": np.random.normal(0, 1, 100), + "f2": np.random.normal(5, 2, 100) + }) + # Create synthetic data by adding small noise + synthetic_dp = real_dp + np.random.normal(0, 0.5, real_dp.shape) + dp = DisclosureProtection(real_dp, synthetic_dp) + score = dp.score() + report = dp.report() + self.assertIsInstance(score, float) + self.assertIsInstance(report, dict) + self.assertIn("threshold", report) + self.assertIn("risk_rate", report) + self.assertIn("disclosure_protection_score", report) + +# ------------------------------- +# Tests for DataProcessor +# ------------------------------- +class TestDataProcessor(unittest.TestCase): + def setUp(self): + # Create a DataFrame with different types. + self.df = pd.DataFrame({ + "numeric": np.random.normal(10, 2, 50), + "categorical": np.random.choice(["Red", "Green", "Blue"], 50), + "boolean": np.random.choice([True, False], 50), + "datetime": pd.date_range("2023-01-01", periods=50), + "timedelta": pd.to_timedelta(np.random.randint(1, 100, 50), unit="D"), + "float": np.random.uniform(0, 1, 50) + }) + self.metadata = { + "numeric": "numerical", + "categorical": "categorical", + "boolean": "boolean", + "datetime": "datetime", + "timedelta": "timedelta", + "float": "numerical" + } + self.processor = DataProcessor(self.metadata) + + def test_preprocess_postprocess(self): + # Preprocess the data + processed = self.processor.preprocess(self.df) + self.assertIsInstance(processed, pd.DataFrame) + # Check that categorical columns are encoded (i.e. no string values remain) + for col, dtype in self.metadata.items(): + if dtype == "categorical": + self.assertTrue(np.issubdtype(processed[col].dtype, np.number) or col not in processed.columns) + # Simulate synthetic data as processed copy then postprocess back + synthetic_processed = processed.copy() + recovered = self.processor.postprocess(synthetic_processed) + self.assertIsInstance(recovered, pd.DataFrame) + # Check that the recovered DataFrame has the original columns order. + self.assertListEqual(list(recovered.columns), list(self.df.columns)) + + def test_validate_raises_on_missing_column(self): + # Remove one column so that validation should fail. + df_missing = self.df.drop(columns=["numeric"]) + with self.assertRaises(InvalidDataError): + self.processor.validate(df_missing) + +# ------------------------------- +# Tests for MissingDataHandler +# ------------------------------- +class TestMissingDataHandler(unittest.TestCase): + def setUp(self): + # Create a DataFrame with missing values in different types. + self.df = pd.DataFrame({ + "num": [1, 2, np.nan, 4, 5], + "cat": ["a", np.nan, "b", "a", "c"], + "bool": [True, False, np.nan, True, False], + "datetime": pd.to_datetime(["2023-01-01", np.nan, "2023-01-03", "2023-01-04", "2023-01-05"]), + "timedelta": pd.to_timedelta([1, 2, np.nan, 4, 5], unit="D") + }) + self.handler = MissingDataHandler() + + + def test_apply_imputation(self): + # First, detect missingness; we won't get perfect detection, but just test that imputation runs. + missingness = self.handler.detect_missingness(self.df) + imputed = self.handler.apply_imputation(self.df, missingness) + # Check that after imputation there are no missing values. + self.assertFalse(imputed.isna().any().any()) + +# ------------------------------- +# Tests for GaussianCopulaMethod +# ------------------------------- +class TestGaussianCopulaMethod(unittest.TestCase): + def setUp(self): + # Create a simple DataFrame with numerical and categorical columns. + self.df = pd.DataFrame({ + "numeric": np.random.normal(50, 10, 100), + "categorical": np.random.choice(["Red", "Green", "Blue"], 100) + }) + self.metadata = { + "numeric": "numerical", + "categorical": "categorical" + } + # For simplicity, we use the DataProcessor to convert data to numeric space. + self.processor = DataProcessor(self.metadata) + self.processed = self.processor.preprocess(self.df) + self.gc = GaussianCopulaMethod(self.metadata) + self.gc.fit(self.processed) + + def test_sample_shape(self): + # Use the sample method with a requested number of rows. + num_samples = 50 + synthetic = self.gc.sample(num_samples) + self.assertIsInstance(synthetic, pd.DataFrame) + self.assertEqual(len(synthetic), num_samples) + + def test_get_learned_distributions(self): + # After fitting, learned distributions should be available. + distributions = self.gc.get_learned_distributions() + self.assertIsInstance(distributions, dict) + # Check that keys correspond to columns in metadata. + for col in self.metadata.keys(): + self.assertIn(col, distributions) + +if __name__ == "__main__": + unittest.main() diff --git a/tests_processing.py b/tests_processing.py deleted file mode 100644 index a01f5eb..0000000 --- a/tests_processing.py +++ /dev/null @@ -1,44 +0,0 @@ -import unittest -from synthpop import Synthpop -import pandas as pd -import numpy as np - -class TestProcessing(unittest.TestCase): - - def test_add_NaN_columns_for_numeric_columns(self): - df = pd.DataFrame({'a':[1,2,np.nan], 'b':[1,1,1], 'c':['x','y',None]}) - spop = Synthpop() - dtype_map = {'a':'float','b':'float', 'c':'categorical'} - res,dtype_res = spop.pre_preprocess(df,dtype_map,nan_fill=-8) - - self.assertTrue('a_NaN' in res,"Nan column not made") - self.assertFalse('b_NaN' in res,"Nan column should not be made if there are no NaNs") - self.assertFalse('c_NaN' in res,"Nan column should not be made for categorical columns") - self.assertTrue(res['a_NaN'][2]) - self.assertEqual(res['a'][2], -8) - self.assertEqual(dtype_res['a_NaN'],'category') - self.assertEqual(spop.map_column_to_NaN_column['a'],'a_NaN') - def test_make_visit_sequence_when_one_is_given(self): - - visit_seq = ['x','a','b'] - spop = Synthpop(visit_sequence=visit_seq) - spop.map_column_to_NaN_column = {'a':'a_NaN','c':'c_NaN'} - - spop.include_nan_columns() - - self.assertSequenceEqual(spop.visit_sequence,['x','a_NaN','a','b']) - - - def test_apply_and_remove_added_NaN_columns(self): - df = pd.DataFrame({'a':[1,2,-8],'a_NaN':[False,True,False], 'b':[1,1,1], 'c':['x','y',None]}) - - spop = Synthpop() - spop.map_column_to_NaN_column = {'a':'a_NaN'} - - res = spop.post_postprocessing(df) - self.assertTrue(np.isnan(res['a'][1]), "NaNs should be placed where indicated") - self.assertFalse('a_NaN' in res, "indicator columns should be removed") - - -if __name__ == '__main__': - unittest.main() \ No newline at end of file

$!jHKq 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