The classes in synthesized.common.rules allow the user to constrain the synthetic dataset, ensuring it confirms to pre-defined business logic, or a custom scenario. They can be used with the ConditionalSampler to generate custom synthetic data:

from synthesized import ConditionalSampler
sampler = ConditionalSampler(synthesizer=...)
df_synth = sampler.synthesize(num_rows=..., association_rules=..., generic_rules=..., expression_rules=...)


Association rules can only be declared between columns containing categorical variables.

Often, datasets may contain two columns with an important well-defined relationship. For example:

Table 1. cars-original.csv
Make Model Total
















In the above dataset, "Make" has a one-to-many association with "Model". In other words, certain categories in "Model" only appear with certain categories in "Make". The HighDimSynthesizer captures highly detailed dataset-wide information, but as it also attempts to generalize specific row-level information, a case such as "Polo" always appearing with "Volkswagen" isn’t strictly followed. A possible output of the synthesizer could be:

Table 2. cars-synthetic.csv
Make Model Total










In this example, the HighDimSynthesizer has generated a row with a "BMW Polo", which is an unrealistic combination. If capturing strict column associations such as this is important, the synthesizer can be configured to do so by defining an Association rule.

from synthesized.common.rules import Association
rule = Association.detect_association(df, df_meta, associations=["car_manufacturer", "car_model"])

In addition, sometimes empty values are correlated, e.g: if one column specifies the number of children in a family, we would expect that the names of these children to be empty if they don’t exist:

rule = Association.detect_association(df, df_meta, associations=["NumberOfChildren"], nan_associations=["Child1Name", "Child2Name", ...])

The association class contains a class method Association.detect_association that automatically detects these rules between the columns, if some category of a column never appears with another then it can force the Synthesizer to never output those values together. However, if a specific rule is required that isn’t present in the data the Association can be initialized on its own.

rule = Association(binding_mask=binding_mask, associations=..., nan_association=...)

Here the binding mask specifies the possible outputs of the Synthesizer, this isn’t currently user-friendly to construct due to its lack of use-case.

There are some constraints on what rules you can define: the Synthesizer only allows a column to appear in one association and a column cannot appear in both the association and nan_association arguments. Some of these constraints may be possible to change in the future.

Columns and Values

When using rules, we sometimes want to refer to specific columns in a table or to a specific string or numerical value. To make this clear to the ConditionalSampler, We use the classes Column and Value.

from synthesized.common.rules import Column, Value
column = Column("A") # refers to column A
value = Value(10) # refers to the value 10

These can then be used in expression rules and generic rules.


When it is known a priori that a field in a dataset is related to others through a mathematical transformation, this can be enforced with an Expression rule. This takes a string expression that can be parsed by pandas.eval

from synthesized.common.rules import Expression, Column
column = Column("A")
rule = Expression(column=column, expr="a+b+c")


A GenericRule is a special type of rule that can be enforced by conditional sampling of ConditionalSampler.

As these rules are enforced by iterative conditional sampling, it may not be possible to fully generate the desired number of rows if the rules cannot be fulfilled, or represent a very small proportion of the original data. In this case, it will return the data it was able to generate. Increasing the max_trials parameter may resolve this issue.


ValueRange can be used to constrain synthesized data to a user-defined range, either to improve the quality of the synthetic data or to generate custom scenarios. The upper and lower bounds of the range can be numeric, e.g., '0 < x < 10'.

from synthesized.common.rules import ValueRange, Column
column = Column("x")
values = [Value(0), Value(10)]
rule = ValueRange(v1=column, v2=values)

or they can be defined by another field of the dataset, e.g z < x < y

from synthesized.common.rules import ValueRange, Column
column_x = Column("x")
bounds = [Column("z"), Column("y")]
rule = ValueRange(v1=column_x, v2=bounds)


Equals enforces the field of a dataset to be strictly equal to a specified value, either numeric or categorical.

from synthesized.common.rules import Equals, Column
column_x = Column("x")
column_A = Column("A")
rule = Equals(column_x, column_A)


IsIn is similar to Equals, but specifies a list of allowed values.

from synthesized.common.rules import IsIn, Column, Value
column = Column("x")
values = [Value(i) for i in ['A', 'B']]
rule = IsIn(column, values)