tuner#

Interface for tuning SessionPrograms.

Warning

SessionProgramTuner is intended to be used for tuning DP programs. It does not provide any privacy guarantees. It is recommended to use synthetic or historical data for tuning instead of the data that will be used in production.

The SessionProgramTuner class is an abstract base class that defines the interface for tuning SessionPrograms. To tune a specific program, users should subclass SessionProgramTuner, passing their SessionProgram as the program class argument.

>>> class Program(SessionProgram):
...     class ProtectedInputs:
...         protected_df: DataFrame
...     class Outputs:
...         a_sum: DataFrame
...     class Parameters:
...         low: int
...         high: int
...     def session_interaction(self, session: Session):
...         low = self.parameters["low"]
...         high = self.parameters["high"]
...         sum_query = QueryBuilder("protected_df").sum("a", low, high)
...         a_sum = session.evaluate(sum_query, self.privacy_budget)
...         return {"a_sum": a_sum}
>>> class Tuner(SessionProgramTuner, program=Program):
...     baseline_options = {
...         "use_clamping_bounds": NoPrivacySession.Options(
...             enforce_clamping_bounds=True
...         ),
...         "ignore_clamping_bounds": NoPrivacySession.Options(
...             enforce_clamping_bounds=False
...         ),
...     }
...
...     @baseline("custom_baseline")
...     def no_clamping_bounds_baseline(protected_inputs: Dict[str, DataFrame]) -> Dict[str, DataFrame]:
...         df = protected_inputs["protected_df"]
...         sum_value = df.agg(sf_sum("a").alias('a_sum'))
...         return {"a_sum": sum_value}
...
...     @metric(name="root_mean_squared_error", output="a_sum")
...     def compute_rmse(
...         dp_outputs: DataFrame, baseline_outputs: DataFrame
...     ):
...         total_sum_dp = dp_outputs.select("a_sum").collect()[0]["a_sum"]
...         total_sum_baseline = (
...             baseline_outputs.select("a_sum").collect()[0]["a_sum"]
...         )
...         squared_error = (total_sum_dp - total_sum_baseline) ** 2
...         return math.sqrt(squared_error)
...
...     metrics = [
...         RelativeError(
...             "a_sum",
...             column="a_sum",
...             baselines=list(baseline_options.keys()) + ["custom_baseline"],
...         ),
...     ] # This is required to use the built-in metrics

Just like a SessionProgram, once a subclass of SessionProgramTuner is defined, it can be instantiated using the automatically-generated builder for that class. Unlike a SessionProgram, you can pass Tunable objects to the builder methods instead of concrete values.

>>> protected_df = spark.createDataFrame([(1, 2), (3, 4)], ["a", "b"])
>>> tuner = (
...     Tuner.Builder()
...     .with_privacy_budget(Tunable("budget"))
...     .with_private_dataframe("protected_df", protected_df, AddOneRow())
...     .with_parameter("low", 0)
...     .with_parameter("high", Tunable("high"))
...     .build()
... )

The outputs() method can be used to run the program to get the outputs of the DP and baseline programs.

>>> dp_outputs, baseline_outputs = (
...     tuner.outputs({"budget": PureDPBudget(1), "high": 1})
... )

The error_report() method on the tuner can be used to run the program to get the DP and baseline outputs as well as the metrics defined in the Tuner class.

>>> tuner.error_report({"budget": PureDPBudget(1), "high": 1}).show()  
Error report ran with budget PureDPBudget(epsilon=1) and the following tunable parameters:
budget: PureDPBudget(epsilon=1)
high: 1
and the following additional parameters:
low: 0

Metric results:
+---------+-----------------------------+------------------------+------------------------------------------------+
|   Value | Metric                      | Baseline               | Description                                    |
+=========+=============================+========================+================================================+
|    1.5  | a_sum.relative_error(a_sum) | use_clamping_bounds    | Relative error for column a_sum of table a_sum |
+---------+-----------------------------+------------------------+------------------------------------------------+
|    1.25 | a_sum.relative_error(a_sum) | ignore_clamping_bounds | Relative error for column a_sum of table a_sum |
+---------+-----------------------------+------------------------+------------------------------------------------+
|    1.25 | a_sum.relative_error(a_sum) | custom_baseline        | Relative error for column a_sum of table a_sum |
+---------+-----------------------------+------------------------+------------------------------------------------+
|    3    | root_mean_squared_error     | use_clamping_bounds    | User-defined metric (no description)           |
+---------+-----------------------------+------------------------+------------------------------------------------+
|    5    | root_mean_squared_error     | ignore_clamping_bounds | User-defined metric (no description)           |
+---------+-----------------------------+------------------------+------------------------------------------------+
|    5    | root_mean_squared_error     | custom_baseline        | User-defined metric (no description)           |
+---------+-----------------------------+------------------------+------------------------------------------------+

Functions#

`baseline()`	Decorator to define a custom baseline method for `SessionProgramTuner`.
`metric()`	Decorator to define a custom metric method for `SessionProgram`.
`view()`	Views of the output table to be used across metrics in place of program outputs.

baseline(name)#

Decorator to define a custom baseline method for SessionProgramTuner.

To use the “default” baseline in addition to this custom baseline, you need to separately specify “default”: NoPrivacySession.Options() in baseline_options class variable.

Parameters: name (str) – A name for the custom baseline.

>>> from tmlt.analytics.session import Session

>>> class Program(SessionProgram):
...     class ProtectedInputs:
...         protected_df: DataFrame
...     class UnprotectedInputs:
...         unprotected_df: DataFrame
...     class Outputs:
...         output_df: DataFrame
...     def session_interaction(self, session: Session):
...         ...
>>> class Tuner(SessionProgramTuner, program=Program):
...     @baseline("custom_baseline")
...     def custom_baseline(
...         protected_inputs: Dict[str, DataFrame],
...     ) -> Dict[str, DataFrame]:
...         ...
...     @baseline("another_custom_baseline")
...     def another_custom_baseline(
...         self,
...         protected_inputs: Dict[str, DataFrame],
...         unprotected_inputs: Dict[str, DataFrame],
...     ) -> Dict[str, DataFrame]:
...         # If the program has unprotected inputs or parameters, the custom
...         # baseline method can take them as an argument.
...         ...
...     baseline_options = {
...         "default": NoPrivacySession.Options()
...     }  # This is required to keep the default baseline

metric(name, output, description=None, baselines=None)#

Decorator to define a custom metric method for SessionProgram.

Alternatively, you can use CustomSingleOutputMetric directly.

To use the built-in metrics in addition to this custom metric, you can separately specify metrics class variable.

Parameters

name (str) – A name for the metric.
description (Optional[str]) – A description of the metric.
output (str) – The output to compute the metric for.
baselines (Optional[Union[str, List[str]]]) – The name of the baseline program(s) used for the error report. If None, use all baselines specified as custom baseline and baseline options on tuner class. If no baselines are specified on tuner class, use default baseline. If a string, use only that baseline. If a list, use only those baselines.

>>> from tmlt.analytics.session import Session
>>> from tmlt.analytics.metrics import AbsoluteError

>>> class Program(SessionProgram):
...     class ProtectedInputs:
...         protected_df: DataFrame
...     class UnprotectedInputs:
...         unprotected_df: DataFrame
...     class Outputs:
...         output_df: DataFrame
...     def session_interaction(self, session: Session):
...         return {"output_df": dp_output}
>>> class Tuner(SessionProgramTuner, program=Program):
...     @metric(name="custom_metric", output="output_df")
...     def custom_metric(
...         dp_outputs: DataFrame, baseline_outputs: DataFrame
...     ):
...         # If the program has unprotected inputs and/or parameters, the custom
...         #  metric method can take them as an argument.
...         ...
...     metrics = [
...         AbsoluteError(output="output_df", column="Y"),
...     ]  # This is required to use the built-in metrics

view(name)#

Views of the output table to be used across metrics in place of program outputs.

Parameters: name (str) – A name for the output view.

>>> from tmlt.analytics.session import Session
>>> from tmlt.analytics.metrics import RelativeError

>>> class Program(SessionProgram):
...     class ProtectedInputs:
...         protected_df: DataFrame
...     class UnprotectedInputs:
...         unprotected_df: DataFrame
...     class Outputs:
...         output_df: DataFrame
...     def session_interaction(self, session: Session):
...         ...
>>> class Tuner(SessionProgramTuner, program=Program):
...     @view("output_view")
...     def custom_view1(
...         outputs: Dict[str, DataFrame],
...     ) -> DataFrame:
...         ...
...     @view("another_output_view")
...     def custom_view2(
...         self,
...         outputs: Dict[str, DataFrame],
...         unprotected_inputs: Dict[str, DataFrame],
...     ) -> DataFrame:
...         # If the program has unprotected inputs or parameters, the view method
...         # can take them as an argument.
...         ...
...     metrics = [
...         RelativeError("output_view", column="a_sum"),
...     ] # The view can be used instead of output when metric is defined

Classes#

`SessionProgramTuner`	Base class for defining an object to tune inputs to a `SessionProgram`.
`Tunable`	Named placeholder for a single input to a `Builder`.
`ErrorReport`	Output of a single error report run.
`MultiErrorReport`	Output of an error report run across multiple input combinations.
`UnprotectedInput`	An unprotected input that was used for an `ErrorReport`.
`ProtectedInput`	A protected input that was used for an `ErrorReport`.

class SessionProgramTuner(builder)#

Base class for defining an object to tune inputs to a SessionProgram.

Note

This is only available on a paid version of Tumult Analytics. If you would like to hear more, please contact us at info@tmlt.io.

SessionProgramTuners should not be directly constructed. Instead, users should create a subclass of SessionProgramTuner, then construct their SessionProgramTuner using the auto-generated Builder attribute of the subclass.

Parameters: builder (SessionProgramTuner) –

class Builder#

The builder for a specific subclass of SessionProgramTuner.

with_private_dataframe(source_id, dataframe, protected_change)#

Add a tunable private dataframe to the builder.

Parameters

source_id (str) –
dataframe (Union[pyspark.sql.DataFrame, Tunable]) –
protected_change (Union[tmlt.analytics.protected_change.ProtectedChange, Tunable]) –

Return type

SessionProgramTuner

with_public_dataframe(source_id, dataframe)#

Add a tunable public dataframe to the builder.

Parameters

source_id (str) –
dataframe (Union[pyspark.sql.DataFrame, Tunable]) –

Return type

SessionProgramTuner

with_parameter(name, value)#

Set the value of a parameter.

Parameters

name (str) –
value (Any) –

build()#

Returns an instance of the matching SessionProgramTuner subtype.

Return type: SessionProgramTuner

with_id_space(id_space)#

Adds an identifier space.

This defines a space of identifiers that map 1-to-1 to the identifiers being protected by a table with the AddRowsWithID protected change. Any table with such a protected change must be a member of some identifier space.

Parameters: id_space (str) –

with_privacy_budget(privacy_budget)#

Set the privacy budget for the object being built.

Parameters: privacy_budget (Union[tmlt.analytics.privacy_budget.PrivacyBudget, Tunable]) –

baseline_options :Optional[Union[Dict[str, tmlt.analytics.no_privacy_session.NoPrivacySession.Options], tmlt.analytics.no_privacy_session.NoPrivacySession.Options]]#

Configuration for how baseline outputs are computed.

By default, a SessionProgramTuner computes both the DP outputs and the baseline outputs for a SessionProgram to compute metrics. The baseline outputs are computed by calling the session_interaction() method with a NoPrivacySession. The baseline_options attribute allows you to override the default options for the NoPrivacySession used to compute the baseline. You can also specify multiple configurations to compute the baselines with different options. When multiple baseline configurations are specified, the metrics are computed with respect to each of the baseline configurations (unless specified otherwise in the metric definitions).

To override the default baseline options (see Options), you can set this to an Options object.

If you want to specify multiple baseline configurations, you can set this to a dictionary mapping baseline names to Options.

metrics :Optional[List[tmlt.analytics.metrics.Metric]]#: A list of metrics to compute in each error_report.

program :Type[tmlt.analytics.program.SessionProgram]#: A subclass of SessionProgram to be tuned.

__init__(builder)#

Constructor.

Warning

This constructor is not intended to be used directly. Use the automatically generated builder instead. It can be accessed using the Builder attribute of the subclass.

Parameters: builder (tmlt.analytics.tuner._tuner.SessionProgramTuner.Builder) –

property tunables#

Returns a list of tunable inputs associated with this tuner.

Return type: List[Tunable]

outputs(tunable_values=None)#

Computes all outputs for a single run.

Parameters: tunable_values (Optional[Dict[str, Any]]) – A dictionary mapping names of Tunables to concrete values to use for this run. Every Tunable used in building this tuner must have a value in this dictionary. This can be None only if no Tunables were used.
Return type: Tuple[Dict[str, pyspark.sql.DataFrame], Dict[str, Dict[str, pyspark.sql.DataFrame]]]

error_report(tunable_values=None)#

Computes DP outputs, baseline outputs, and metrics for a single run.

Parameters: tunable_values (Optional[Dict[str, Any]]) – A dictionary mapping names of Tunables to concrete values to use for this error report. Every Tunable used in building this tuner must have a value in this dictionary. This can be None only if no Tunables were used.
Return type: tmlt.analytics.tuner._error_report.ErrorReport

multi_error_report(tunable_values_list)#

Runs the error_report for each set of values for the Tunables.

Parameters: tunable_values_list (List[Dict[str, Any]]) –
Return type: tmlt.analytics.tuner._error_report.MultiErrorReport

class Tunable#

Named placeholder for a single input to a Builder.

Note

This is only available on a paid version of Tumult Analytics. If you would like to hear more, please contact us at info@tmlt.io.

When a Tunable is passed to a Builder, it is replaced with the concrete values for the tunable parameter when building SessionProgram s inside of methods like error_report() and multi_error_report().

name :str#: Name of the tunable parameter.

class ErrorReport#

Output of a single error report run.

Note

This is only available on a paid version of Tumult Analytics. If you would like to hear more, please contact us at info@tmlt.io.

This class is not intended to be constructed directly. Instead, it is returned by the error_report() method.

tunable_values :Dict[str, Any]#: The values of the tunable parameters used for this error report.

parameters :Dict[str, Any]#: The non-tunable parameters used for this error report.

protected_inputs :Dict[str, ProtectedInput]#: The protected inputs used for this error report.

unprotected_inputs :Dict[str, UnprotectedInput]#: The unprotected inputs used for this error report.

privacy_budget :tmlt.analytics.privacy_budget.PrivacyBudget#: The privacy budget used for this error report.

dp_outputs :Dict[str, pyspark.sql.DataFrame]#: The differentially private outputs of the program.

baseline_outputs :Dict[str, Dict[str, pyspark.sql.DataFrame]]#: The outputs of the baseline program.

metrics :List[tmlt.analytics.metrics._base.MetricOutput]#: The metrics computed on the outputs of the dp and baseline programs.

format()#: Return a string representation of this object.

show()#: Prints the error report in a nicely-formatted, human-readable way.

class MultiErrorReport(reports)#

Output of an error report run across multiple input combinations.

Note

This is only available on a paid version of Tumult Analytics. If you would like to hear more, please contact us at info@tmlt.io.

This class is not intended to be constructed directly. Instead, it is returned by the multi_error_report() method.

Parameters: reports (List[ErrorReport]) –

__init__(reports)#

Constructor.

Warning

This class is not intended to be constructed directly. Instead, it is returned by the multi_error_report() method.

Parameters: reports (List[ErrorReport]List[ErrorReport]) – An error report for each run.

property reports#

Return the error reports.

Return type: List[ErrorReport]

__iter__()#

Return an iterator over the error reports.

Return type: Iterator[ErrorReport]

to_dataframe()#

Return a dataframe representation of the error reports.

The dataframe will have a row for each error report (run) and a column for each tunable and metric.

Return type: pandas.DataFrame

class UnprotectedInput#

Bases: NamedTuple

An unprotected input that was used for an ErrorReport.

name :str#: The name of the input.

dataframe :pyspark.sql.DataFrame#: A dataframe containing the unprotected data used for the report.

class ProtectedInput#

Bases: NamedTuple

A protected input that was used for an ErrorReport.

Warning

Note that normally ProtectedInputs are treated as sensitive and would not accessible to the user except through the Session API to avoid violating differential privacy. But these error reports are not differentially private, and for this reason it is highly recommended to avoid using sensitive data in error reports, and to instead use synthetic data or other non-sensitive data.

For these reasons, the protected inputs used in error reports are attached to the outputs for your convenience, but it is ultimately your responsibility to ensure that truly sensitive data is not used inappropriately.

name :str#: The name of the input.

dataframe :pyspark.sql.DataFrame#: A dataframe containing the protected data used for the report.

protected_change :tmlt.analytics.protected_change.ProtectedChange#: What changes to the protected data the Session should protect.

Tumult Analytics Pro

tuner#

Functions#

Classes#