Add BaseHierarchicalSampler Mixin

[amontanez24]

Problem Description

There is not currently a unified abstraction for multi table synthesizers. This has led to diverging implementations for HMASynthesizer and HSASynthesizer. Additionally it leads to the following issues:

• It is not easy to add new, multi table models: Over the lifetime of DataCebo, we expect to be creating many different multi table synthesizers.
• It is not easy to fix existing bugs: If there is a general bug that affects modeling and sampling for all multi-table synthesizers, we should be able to make the fix in only 1 place.
• It is not easy to add common features between all synthesizers: For example, it may be nice to include some verbosity (progress bars, logger info, etc.) during the fitting and sampling for all synthesizers.

As a solution, we propose creating mixins that unify multi table sampling based on two strategies:

1. Hierarchical
2. Independent

This issue focuses on the Hierarchical strategy.

Expected behavior

Add a new mixin called HierarchicalSampler to the sdv.sampling module.

Methods

These methods should all have an implementation in the base mixin itself.

• _sample(self, scale=1.0)
  • Args
    • scale (float): A float representing how much to scale the data by.
  • Returns: A dictionary containing as keys the names of the tables and as values the sampled data tables as pandas.DataFrame.
  • pseudo-code

  sampled_data = {}
  roots = get_tables_with_no_parents()
  for root in roots:
      num_rows = get_num_rows(root, scale)
      synthesizer = self._synthesizers[root]
      self._sample_table(synthesizer, root, num_rows, sampled_data)
  for relationship in relationships:
      self._add_foreign_key_column(child_table, parent_table, child_name, parent_name)
  self._finalize()

• _sample_table(self, synthesizer, table_name, num_rows, sampled_data=None)
  • Args
    • synthesizer (SingleTableSynthesizer): Synthesizer to sample from
    • table_name (string): Name of the table to sample
    • num_rows (int): Number of rows to sample.
    • sampled_data (dict): Dictionary of data sampled so far.
  • pseudo-code

  data = synthesizer._sample(num_rows)
  sampled_data[table_name] = data
  for child in self.get_children(table_name):
      for row in data:
          self.add_child_rows(row, child, sampled_data)

• _add_child_rows(parent_row, child_name, sampled_data)
  • Args
    • parent_row (dataframe): Row of parent data to get child rows for
    • child_name(string): Name of child table
    • sampled_data (dict): Dictionary of data sampled so far.
  • pseudo-code

      child_synthesizer = self._recreate_child_synthesizer(child_name, parent_rows)
      num_rows = get_num_rows_for_parent()
      self.sample_table(child_synthesizer, child_name, num_rows, sampled_data)

• _finalize(sampled_data)
  • Args
    • sampled_data (dict): Dictionary of data sampled so far.
  • pseudo-code

  for table, data in sampled_data.items():
      remove_added_columns(data)

Abstract methods

These methods do not need to be implemented here but any class that uses this mixin must implement them.

• _recreate_child_synthesizer(child_name, parent_row): This method should create a SingleTableSynthesizer for the child based on the values in its parent's row.
• _add_foreign_key_column(child_table, parent_table, child_name, parent_name): This method should add a column for the foreign key that connects the child to the parent. It can use whatever logic it needs to figure out which values to use for each child row.

Additional context

• This mixin follows the current HMA sampling process pretty closely. The main difference will be breaking the steps into the appropriate methods.

• The goal is that at the end, to add a new hierarchical multi table synthesizer, the only methods needed will be one to link child rows to parent rows, and one to create a child synthesizer from a parent row.