Connected tabular generator with dataset_generator

synthetic_data/dataset_generator.py

@@ -137,4 +137,5 @@ def generate_dataset(
             else:
                 dataset.append(generated_data)
         column_names.append(name)
+
     return convert_data_to_df(dataset, column_names=column_names)

synthetic_data/distinct_generators/int_generator.py

@@ -20,4 +20,6 @@ def random_integers(
 
     :return: np array of integers
     """
+    if max_value <= 0:
+        max_value = 1e6
     return rng.integers(min_value, max_value, (num_rows,))

synthetic_data/distinct_generators/text_generator.py

@@ -39,6 +39,10 @@ def random_text(
         )
     text_list = []
 
+    # edge case
+    if str_len_min == str_len_max:
+        str_len_max += 1
+
     for _ in range(num_rows):
         length = rng.integers(str_len_min, str_len_max)
         string_entry = "".join(rng.choice(chars, (length,)))

synthetic_data/generator_builder.py

@@ -35,7 +35,7 @@ def __new__(cls, seed=None, config=None, *args, **kwargs):
 
         profile = kwargs.pop("profile", None)
         data = kwargs.pop("data", None)
-        if not profile and not data:
+        if not profile and data is None:
             raise ValueError(
                 "No profile object or dataset was passed in kwargs. "
                 "If you want to generate synthetic data from a "

synthetic_data/generators.py

@@ -1,20 +1,30 @@
 """Contains generators for tabular, graph, and unstructured data profiles."""
 
 import dataprofiler as dp
+import numpy as np
+import pandas as pd
 from sklearn import preprocessing
 
 from synthetic_data.base_generator import BaseGenerator
+from synthetic_data.dataset_generator import generate_dataset
 from synthetic_data.graph_synthetic_data import GraphDataGenerator
 from synthetic_data.synthetic_data import make_data_from_report
 
 
 class TabularGenerator(BaseGenerator):
     """Class for generating synthetic tabular data."""
 
-    def __init__(self, profile, seed=None, noise_level: float = 0.0):
+    def __init__(
+        self, profile, seed=None, noise_level: float = 0.0, is_correlated: bool = True
+    ):
         """Initialize tabular generator object."""
         super().__init__(profile, seed)
         self.noise_level = noise_level
+        self.is_correlated = is_correlated
+        if not seed:
+            seed = self.seed
+        self.rng = np.random.default_rng(seed=seed)
+        self.col_data = []
 
     @classmethod
     def post_profile_processing_w_data(cls, data, profile):
@@ -47,20 +57,114 @@ def post_profile_processing_w_data(cls, data, profile):
             )
         return profile
 
-    def synthesize(self, num_samples: int, seed=None, noise_level: float = None):
+    def synthesize(
+        self,
+        num_samples: int,
+        seed=None,
+        noise_level: float = None,
+    ):
         """Generate synthetic tabular data."""
-        if seed is None:
+        if not seed:
             seed = self.seed
 
         if noise_level is None:
             noise_level = self.noise_level
 
-        return make_data_from_report(
-            report=self.profile.report(),
-            n_samples=num_samples,
-            noise_level=noise_level,
-            seed=seed,
-        )
+        if self.is_correlated:
+            return make_data_from_report(
+                report=self.profile.report(),
+                n_samples=num_samples,
+                noise_level=noise_level,
+                seed=seed,
+            )
+        else:
+            columns = self.profile.report()["data_stats"]
+
+            for col in columns:
+                generator = col.get("data_type", None)
+                order = col.get("order", None)
+                col_stats = col["statistics"]
+                min_value = col_stats.get("min", None)
+                max_value = col_stats.get("max", None)
+
+                if generator == "datetime":
+                    date_format = col_stats["format"]
+                    start_date = pd.to_datetime(
+                        col_stats.get("min", None), format=date_format[0]
+                    )
+                    end_date = pd.to_datetime(
+                        col_stats.get("max", None), format=date_format[0]
+                    )
+                    self.col_data.append(
+                        {
+                            "generator": generator,
+                            "name": "dat",
+                            "date_format_list": [date_format[0]],
+                            "start_date": start_date,
+                            "end_date": end_date,
+                            "order": order,
+                        }
+                    )
+                elif generator == "int":
+                    self.col_data.append(
+                        {
+                            "generator": "integer",
+                            "name": generator,
+                            "min_value": min_value,
+                            "max_value": max_value,
+                            "order": order,
+                        }
+                    )
+
+                elif generator == "float":
+                    self.col_data.append(
+                        {
+                            "generator": generator,
+                            "name": "flo",
+                            "min_value": min_value,
+                            "max_value": max_value,
+                            "sig_figs": int(
+                                col_stats.get("precision", None).get("max", None)
+                            ),
+                            "order": order,
+                        }
+                    )
+
+                elif generator == "string":
+                    if col_stats.get("categorical", False):
+                        total = 0
+                        for count in col_stats["categorical_count"].values():
+                            total += count
+
+                        probabilities = []
+                        for count in col_stats["categorical_count"].values():
+                            probabilities.append(count / total)
+
+                        self.col_data.append(
+                            {
+                                "generator": "categorical",
+                                "name": "cat",
+                                "categories": col_stats.get("categories", None),
+                                "probabilities": probabilities,
+                                "order": order,
+                            }
+                        )
+                    else:
+                        self.col_data.append(
+                            {
+                                "generator": "text",
+                                "name": "txt",
+                                "chars": col_stats.get("vocab", None),
+                                "str_len_min": min_value,
+                                "str_len_max": max_value,
+                                "order": order,
+                            },
+                        )
+            return generate_dataset(
+                rng=self.rng,
+                columns_to_generate=self.col_data,
+                dataset_length=num_samples,
+            )
 
 
 class UnstructuredGenerator(BaseGenerator):

synthetic_data/synthetic_data.py

@@ -402,6 +402,7 @@ def make_data_from_report(
     n_samples: int = None,
     noise_level: float = 0.0,
     seed=None,
+    is_correlated: bool = True,
 ) -> pd.DataFrame:
     """Use a DataProfiler report to generate a synthetic data set to mimic the report.
 
@@ -429,7 +430,9 @@ def make_data_from_report(
     n_informative = len(report["data_stats"])
 
     # build covariance matrix
-    R = report["global_stats"]["correlation_matrix"]
+    R = np.eye(n_informative)
+    if is_correlated:
+        R = report["global_stats"]["correlation_matrix"]
 
     stddevs = [stat["statistics"]["stddev"] for stat in report["data_stats"]]
     D = np.diag(stddevs)