In this guide we will go through a series of steps that will let you discover functionalities of the HMA1 class.
HMA1
The sdv.relational.HMA1 class implements what is called a Hierarchical Modeling Algorithm which is an algorithm that allows to recursively walk through a relational dataset and apply tabular models across all the tables in a way that lets the models learn how all the fields from all the tables are related.
sdv.relational.HMA1
Let’s now discover how to use the HMA1 class.
We will start by loading and exploring one of our demo datasets.
In [1]: from sdv import load_demo In [2]: metadata, tables = load_demo(metadata=True)
This will return two objects:
A Metadata object with all the information that SDV needs to know about the dataset.
Metadata
In [3]: metadata Out[3]: Metadata root_path: . tables: ['users', 'sessions', 'transactions'] relationships: sessions.user_id -> users.user_id transactions.session_id -> sessions.session_id In [4]: metadata.visualize();
For more details about how to build the Metadata for your own dataset, please refer to the Relational Metadata Guide.
A dictionary containing three pandas.DataFrames with the tables described in the metadata object.
pandas.DataFrames
In [5]: tables Out[5]: {'users': user_id country gender age 0 0 US M 34 1 1 UK F 23 2 2 ES None 44 3 3 UK M 22 4 4 US F 54 5 5 DE M 57 6 6 BG F 45 7 7 ES None 41 8 8 FR F 23 9 9 UK None 30, 'sessions': session_id user_id device os minutes 0 0 0 mobile android 23 1 1 1 tablet ios 12 2 2 1 tablet android 8 3 3 2 mobile android 13 4 4 4 mobile ios 9 5 5 5 mobile android 32 6 6 6 mobile ios 7 7 7 6 tablet ios 21 8 8 6 mobile ios 29 9 9 8 tablet ios 34, 'transactions': transaction_id session_id timestamp amount cancelled 0 0 0 2019-01-01 12:34:32 100.0 False 1 1 0 2019-01-01 12:42:21 55.3 False 2 2 1 2019-01-07 17:23:11 79.5 False 3 3 3 2019-01-10 11:08:57 112.1 True 4 4 5 2019-01-10 21:54:08 110.0 True 5 5 5 2019-01-11 11:21:20 76.3 False 6 6 7 2019-01-22 14:44:10 89.5 False 7 7 8 2019-01-23 10:14:09 132.1 True 8 8 9 2019-01-27 16:09:17 68.0 False 9 9 9 2019-01-29 12:10:48 99.9 False}
Let us now use the HMA1 class to learn this data to be ready to sample synthetic data about new users. In order to do this you will need to:
Import the sdv.relational.HMA1 class and create an instance of it passing the metadata that we just loaded.
metadata
Call its fit method passing the tables dict.
fit
tables
In [6]: from sdv.relational import HMA1 In [7]: model = HMA1(metadata) In [8]: model.fit(tables)
Note
During the previous steps SDV walked through all the tables in the dataset following the relationships specified by the metadata, learned each table using a GaussianCopula Model and then augmented the parent tables using the copula parameters before learning them. By doing this, each copula model was able to learn how the child table rows were related to their parent tables.
Once the training process has finished you are ready to generate new synthetic data by calling the sample_all method from your model.
sample_all
In [9]: new_data = model.sample()
This will return a dictionary of tables identical to the one which the model was fitted on, but filled with new data which resembles the original one.
In [10]: new_data Out[10]: {'users': user_id country gender age 0 0 US NaN 34 1 1 ES M 45 2 2 DE NaN 31 3 3 UK M 32 4 4 DE F 58 5 5 DE NaN 67 6 6 US M 26 7 7 ES F 33 8 8 DE NaN 37 9 9 ES M 25, 'sessions': session_id user_id device os minutes 0 0 0 tablet ios 22 1 1 1 mobile ios 17 2 2 1 mobile android 25 3 3 2 mobile android 39 4 4 2 mobile android 32 5 5 3 mobile android 14 6 6 4 tablet ios -5 7 7 4 tablet ios 2 8 8 4 tablet ios 1 9 9 5 mobile android 15 10 10 7 mobile ios 12 11 11 7 tablet ios 13 12 12 8 mobile android 30 13 13 9 tablet android 32, 'transactions': transaction_id session_id timestamp amount cancelled 0 0 1 2019-01-09 17:41:58 112.065359 True 1 1 2 2019-01-13 11:47:51 69.813277 True 2 2 2 2019-01-13 15:29:15 102.170691 True 3 3 3 2019-01-09 17:18:52 98.804757 True 4 4 3 2019-01-09 22:32:09 113.353776 True 5 5 4 2019-01-10 04:05:10 157.232510 True 6 6 4 2019-01-09 14:35:04 107.401840 True 7 7 5 2019-01-11 14:44:52 84.731469 True 8 8 10 2019-01-27 05:15:54 123.979715 True 9 9 12 2019-01-15 13:29:10 93.451229 True 10 10 12 2019-01-15 11:04:07 124.972761 True 11 11 13 2019-01-13 15:07:03 98.161851 False 12 12 13 2019-01-14 09:53:31 75.810567 False}
In many scenarios it will be convenient to generate synthetic versions of your data directly in systems that do not have access to the original data source. For example, if you may want to generate testing data on the fly inside a testing environment that does not have access to your production database. In these scenarios, fitting the model with real data every time that you need to generate new data is feasible, so you will need to fit a model in your production environment, save the fitted model into a file, send this file to the testing environment and then load it there to be able to sample from it.
sample
Let’s see how this process works.
Once you have fitted the model, all you need to do is call its save method passing the name of the file in which you want to save the model. Note that the extension of the filename is not relevant, but we will be using the .pkl extension to highlight that the serialization protocol used is pickle.
save
.pkl
In [11]: model.save('my_model.pkl')
This will have created a file called my_model.pkl in the same directory in which you are running SDV.
my_model.pkl
Important
If you inspect the generated file you will notice that its size is much smaller than the size of the data that you used to generate it. This is because the serialized model contains no information about the original data, other than the parameters it needs to generate synthetic versions of it. This means that you can safely share this my_model.pkl file without the risk of disclosing any of your real data!
The file you just generated can be sent over to the system where the synthetic data will be generated. Once it is there, you can load it using the HMA1.load method, and then you are ready to sample new data from the loaded instance:
HMA1.load
In [12]: loaded = HMA1.load('my_model.pkl') In [13]: new_data = loaded.sample() In [14]: new_data.keys() Out[14]: dict_keys(['users', 'sessions', 'transactions'])
Warning
Notice that the system where the model is loaded needs to also have sdv installed, otherwise it will not be able to load the model and use it.
sdv
In the steps above we did not tell the model at any moment how many rows we wanted to sample, so it produced as many rows as there were in the original dataset.
If you want to produce a different number of rows you can pass it as the num_rows argument and it will produce the indicated number of rows:
num_rows
In [15]: model.sample(num_rows=5) Out[15]: {'users': user_id country gender age 0 10 US NaN 41 1 11 ES M 17 2 12 BG F 15 3 13 ES NaN 45 4 14 DE F 56, 'sessions': session_id user_id device os minutes 0 14 10 mobile android 19 1 15 12 mobile android -3 2 16 12 tablet ios 0 3 17 14 mobile ios 24, 'transactions': transaction_id session_id timestamp amount cancelled 0 13 14 2019-01-01 00:53:25 114.639859 False 1 14 14 2019-01-01 00:02:19 94.475942 False 2 15 15 2019-01-08 20:19:47 85.460303 False 3 16 16 2019-01-12 15:25:41 118.474475 False 4 17 17 2019-01-19 15:34:53 48.257480 False}
Notice that the root table users has the indicated number of rows but some of the other tables do not. This is because the number of rows from the child tables is sampled based on the values form the parent table, which means that only the root table of the dataset is affected by the passed num_rows argument.
users
In some occasions you will not be interested in generating rows for the entire dataset and would rather generate data for only one table and its children.
To do this you can simply pass the name of the table that you want to sample.
For example, pass the name sessions to the sample method, the model will only generate data for the sessions table and its child table, transactions.
sessions
transactions
In [16]: model.sample('sessions', num_rows=5) Out[16]: {'sessions': session_id user_id device os minutes 0 18 15 mobile ios 26 1 19 17 mobile ios 19 2 20 17 mobile ios 34 3 21 17 mobile android 11 4 22 16 mobile android 5, 'transactions': transaction_id session_id timestamp amount cancelled 0 18 18 2019-01-14 07:01:24 116.438484 True 1 19 18 2019-01-13 07:55:29 157.615669 True 2 20 20 2019-01-22 04:34:14 78.322562 False 3 21 20 2019-01-21 16:10:44 80.799651 False 4 22 21 2019-01-13 11:37:37 102.676932 True 5 23 22 2018-12-30 06:23:52 107.943514 True}
If you want to further restrict the sampling process to only one table and also skip its child tables, you can add the argument sample_children=False.
sample_children=False
For example, you can sample data from the table users only without producing any rows for the tables sessions and transactions.
In [17]: model.sample('users', num_rows=5, sample_children=False) Out[17]: user_id country gender age 0 20 UK NaN 30 1 21 US F 40 2 22 UK F 43 3 23 DE M 66 4 24 BG NaN 43
In this case, since we are only producing a single table, the output is given directly as a pandas.DataFrame instead of a dictionary.
pandas.DataFrame