Вычисление частной статистики с помощью PipelineDP

1. Прежде чем начать

Можно подумать, что сводная статистика не раскрывает никакой информации о конкретных лицах, к которым она относится. Однако существует множество способов, с помощью которых злоумышленник может получить конфиденциальную информацию о людях из сводной статистики.

В этом практическом занятии вы узнаете, как создавать конфиденциальную статистику с использованием дифференциально-приватных агрегаций из PipelineDP для защиты конфиденциальности отдельных лиц. PipelineDP — это фреймворк на Python, позволяющий применять дифференциальную конфиденциальность к большим наборам данных с помощью систем пакетной обработки, таких как Apache Spark и Apache Beam . Более подробную информацию о том, как вычислять дифференциально-приватную статистику на Go , см. в практическом занятии « Конфиденциальность в Beam» .

Конфиденциальность означает, что выходные данные создаются таким образом, чтобы не раскрывать никакой личной информации об отдельных лицах, содержащихся в данных. Этого можно достичь с помощью дифференциальной конфиденциальности — концепции анонимизации , предполагающей высокий уровень конфиденциальности. Анонимизация — это процесс агрегирования данных от нескольких пользователей для защиты их конфиденциальности. Все методы анонимизации используют агрегирование, но не все методы агрегирования обеспечивают анонимизацию. Дифференциальная конфиденциальность, с другой стороны, предоставляет измеримые гарантии от утечки информации и обеспечения конфиденциальности.

Предварительные требования

• Знание языка Python
• Знание основ агрегирования данных.
• Опыт работы с pandas, Spark и Beam.

Что вы узнаете

• Основы дифференциальной конфиденциальности
• Как рассчитать сводную статистику по дифференциальной приватности с помощью PipelineDP
• Как скорректировать результаты с помощью дополнительных параметров конфиденциальности и полезности.

Что вам понадобится

• Для выполнения этого задания в вашей собственной среде вам потребуется установить на компьютер Python версии 3.7 или выше.
• Если вы хотите выполнить практическое задание без собственной среды, вам потребуется доступ к Colaboratory .

2. Понимание дифференциальной конфиденциальности

Чтобы лучше понять дифференциальную конфиденциальность, рассмотрим этот простой пример.

Представьте, что вы работаете в отделе маркетинга интернет-магазина модной одежды и хотите понять, какие из ваших товаров с наибольшей вероятностью будут продаваться.

На этом графике показано, какие товары покупатели просматривали в первую очередь при посещении веб-сайта магазина: футболки, джемперы, носки или джинсы. Футболки — самый популярный товар, а носки — наименее популярный.

Это выглядит полезным, но есть подвох. Когда вы хотите учесть дополнительную информацию, например, совершили ли клиенты покупку или какой товар они просмотрели вторым, вы рискуете раскрыть данные отдельных лиц.

На этом графике показано, что только один покупатель сначала посмотрел на свитер, а затем совершил покупку:

С точки зрения конфиденциальности это не очень хорошо. Анонимизированная статистика не должна раскрывать индивидуальные результаты, так что же делать? Добавлять случайный шум к гистограммам, чтобы сделать их немного менее точными!

Эта столбчатая диаграмма не совсем точна, но все же полезна и не раскрывает индивидуальный вклад каждого участника:

Дифференциальная конфиденциальность — это добавление необходимого количества случайного шума для маскировки индивидуального вклада.

Этот пример чрезмерно упрощен. Правильная реализация дифференциальной конфиденциальности гораздо сложнее и сопряжена с рядом неожиданных нюансов. Как и в криптографии, создание собственной реализации дифференциальной конфиденциальности может быть не лучшей идеей. Вместо этого можно использовать PipelineDP.

3. Загрузите и установите PipelineDP.

Вам не нужно устанавливать PipelineDP и следовать этому руководству, поскольку весь необходимый код и графики вы найдете в этом документе.

Чтобы поэкспериментировать с PipelineDP, запустите его самостоятельно или используйте позже:

• Скачайте и установите PipelineDP:

pip install pipeline-dp

Если вы хотите запустить пример с использованием Apache Beam:

• Скачайте и установите Apache Beam:

pip install apache_beam

Код для этого практического занятия и набор данных можно найти в каталоге PipelineDP/examples/codelab/ .

4. Вычислите показатели конверсии для каждого первого просмотренного товара.

Представьте, что вы работаете в интернет-магазине модной одежды и хотите понять, какие из ваших категорий товаров приносят наибольшее количество и ценность конверсий при первом просмотре. Вы хотите поделиться этой информацией со своим маркетинговым агентством, а также с другими внутренними командами, но при этом хотите предотвратить утечку информации о каком-либо отдельном клиенте.

Для расчета показателей конверсии по каждому первому просмотренному товару на сайте:

1. Просмотрите условный набор данных о посещениях вашего веб-сайта в каталоге PipelineDP/examples/codelab/ .

Этот скриншот — пример набора данных. Он содержит идентификатор пользователя, просмотренные им товары, информацию о совершении конверсии и, если она была совершена, её стоимость.

ID пользователя	product_view_0	product_view_1	product_view_2	product_view_3	product_view_4	has_conversion	конверсия_значение
0	джинсы	футболка	футболка	никто	никто	ЛОЖЬ	0.0
1	джинсы	футболка	джинсы	прыгун	никто	ЛОЖЬ	0.0
2	футболка	прыгун	футболка	футболка	никто	истинный	105.19
3	футболка	футболка	джинсы	никто	никто	ЛОЖЬ	0.0
4	футболка	носки	джинсы	джинсы	никто	ЛОЖЬ	0.0

Вас интересуют следующие показатели:

• view_counts : Количество раз, когда посетители вашего сайта впервые видят каждый товар.
• total_conversion_value : Общая сумма денег, которую посетители тратят при совершении конверсии.
• conversion_rate : Показатель конверсии посетителей.

2. Генерируйте метрики неконфиденциальным способом:

conversion_metrics = df.groupby(['product_view_0'
                               ])[['conversion_value', 'has_conversion']].agg({
                                   'conversion_value': [len, np.sum],
                                   'has_conversion': np.mean
                               })
conversion_metrics = conversion_metrics.rename(
   columns={
       'len': 'view_counts',
       'sum': 'total_conversion_value',
       'mean': 'conversion_rate'
   }).droplevel(
       0, axis=1)

Как вы узнали ранее, эта статистика может раскрыть информацию об отдельных людях в вашем наборе данных. Например, только один человек совершил конверсию после того, как сначала увидел прыгающего человека. При 22 просмотрах ваш коэффициент конверсии составляет приблизительно 0,05. Теперь вам нужно преобразовать каждую столбчатую диаграмму в отдельную.

3. Определите параметры конфиденциальности с помощью класса pipeline_dp.NaiveBudgetAccountant , а затем укажите аргументы epsilon и delta , которые вы хотите использовать для анализа.

Способ установки этих аргументов зависит от конкретной задачи. Чтобы узнать о них больше, см. раздел «Необязательно: Настройка параметров дифференциальной конфиденциальности».

В этом фрагменте кода используются примерные значения:

budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=1e-5)

4. Инициализируйте экземпляр LocalBackend :

ops = pipeline_dp.LocalBackend()

Вы можете использовать экземпляр LocalBackend , поскольку эта программа запускается локально без дополнительных фреймворков, таких как Beam или Spark.

5. Инициализируйте экземпляр DPEngine :

dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

PipelineDP позволяет задавать дополнительные параметры через класс pipeline_dp.AggregateParams , которые влияют на генерацию вашей частной статистики.

params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1,
     max_contributions_per_partition=1)

6. Укажите, что вы хотите рассчитать метрику count и использовать распределение шума LAPLACE .
7. Установите значение аргумента max_partitions_contributed равным 1 .

Этот аргумент ограничивает количество различных посещений, которые может совершить пользователь. Вы ожидаете, что пользователи будут посещать веб-сайт один раз в день, и вас не волнует, посещают ли они его несколько раз в течение дня.

8. Установите значение аргумента max_contributions_per_partitions равным 1 .

Этот аргумент определяет, сколько вкладов может внести один посетитель в отдельный раздел или категорию товаров в данном случае.

9. Создайте экземпляр data_extractor , который укажет, где найти поля privacy_id , partition и value .

Ваш код должен выглядеть примерно так:

def run_pipeline(data, ops):
 budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=1e-5)

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

 params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1, # A single user can only contribute to one partition.
     max_contributions_per_partition=1, # For a single partition, only one contribution per user is used.
     )

 data_extractors = pipeline_dp.DataExtractors(
     privacy_id_extractor=lambda row: row.user_id,
     partition_extractor=lambda row: row.product_view_0
     value_extractor=lambda row: row.has_conversion)

 dp_result = dp_engine.aggregate(data, params, data_extractors)

 budget_accountant.compute_budgets()

 return dp_result

10. Добавьте этот код, чтобы преобразовать ваш DataFrame Pandas в список строк, из которого вы сможете напрямую вычислять статистику дифференциальной приватности:

rows = [index_row[1] for index_row in df.iterrows()]
dp_result_local = run_pipeline(rows, ops) # Returns generator
list(dp_result_local)

Поздравляем! Вы рассчитали свою первую статистику дифференциальной приватности!

На этом графике показан результат подсчета дифференциально приватных элементов рядом с результатом подсчета неприватных элементов, который вы рассчитали ранее:

Гистограмма, которая отображается при запуске кода, может отличаться от этой, и это нормально. Из-за шума в дифференциальной конфиденциальности каждый раз при запуске кода вы получаете другую гистограмму, но вы можете видеть, что они похожи на исходную гистограмму в неконфиденциальной среде.

Обратите внимание, что для обеспечения гарантий конфиденциальности крайне важно не запускать конвейер обработки данных несколько раз. Дополнительную информацию см. в разделе «Вычисление нескольких статистических данных».

5. Используйте общедоступные разделы.

В предыдущем разделе вы, возможно, заметили, что удалили все данные о посещениях для определенной категории посетителей, которые впервые увидели носки на вашем сайте.

Это происходит из-за выбора разделов или порогового значения, что является важным шагом для обеспечения гарантий дифференциальной конфиденциальности, когда существование выходных разделов зависит от самих пользовательских данных. В этом случае само существование раздела в выходных данных может раскрыть существование отдельного пользователя в данных. Чтобы узнать больше о том, почему это нарушает конфиденциальность, см. эту статью в блоге . Для предотвращения этого нарушения конфиденциальности PipelineDP хранит только те разделы, в которых содержится достаточное количество пользователей.

Когда список выходных разделов не зависит от личных данных пользователя, этот этап выбора разделов не требуется. В вашем примере это как раз тот случай, поскольку вы знаете все возможные категории товаров, которые покупатель может увидеть в первую очередь.

Для использования разделов:

1. Создайте список возможных разделов:

public_partitions_products = ['jeans', 'jumper', 'socks', 't-shirt']

2. Передайте список функции run_pipeline() , которая установит его в качестве дополнительного входного параметра для класса pipeline_dp.AggregateParams :

run_pipeline(
    rows, ops, total_delta=0, public_partitions=public_partitions_products)
  # Returns generator

params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     public_partitions=public_partitions_products)

Если вы используете общедоступные разделы и шум LAPLACE , можно установить аргумент total_delta равным 0 .

Теперь вы видите в результате, что отображаются данные по всем разделам или продуктам.

Публичные разделы не только позволяют хранить больше разделов, но и добавляют примерно вдвое меньше шума, поскольку вы не тратите бюджет конфиденциальности на выбор разделов, поэтому разница между исходными и приватными значениями немного меньше по сравнению с предыдущим запуском.

При использовании общедоступных разделов следует помнить о двух важных вещах:

• Будьте осторожны при формировании списка разделов из исходных данных. Если вы не используете метод дифференциальной конфиденциальности, ваш конвейер обработки данных перестанет обеспечивать гарантии дифференциальной конфиденциальности. Для получения дополнительной информации см. раздел «Расширенные настройки: Формирование разделов из данных».
• Если для некоторых общедоступных разделов отсутствуют данные, необходимо добавить к ним шум, чтобы сохранить дифференциальную конфиденциальность. Например, если вы использовали дополнительный товар, такой как брюки, который отсутствует в вашем наборе данных или на вашем веб-сайте, это все равно будет шумом, и результаты могут показать посещения товаров там, где их не было.

Расширенные возможности: Создание разделов на основе данных

Если вы выполняете несколько агрегаций с одним и тем же списком непубличных выходных разделов в одном и том же конвейере, вы можете получить список разделов один раз с помощью метода dp_engine.select_private_partitions() и передать эти разделы каждой агрегации в качестве входных данных public_partitions . Это не только безопасно с точки зрения конфиденциальности, но и позволяет уменьшить информационный шум, поскольку вы используете бюджет конфиденциальности при выборе разделов только один раз для всего конвейера.

def get_private_product_views(data, ops):
 """Obtains the list of product_views in a private manner.

   This does not calculate any private metrics; it merely obtains the list of
   product_views but does so while making sure the result is differentially private.
   """

 # Set the total privacy budget.
 budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=1e-5)

 # Create a DPEngine instance.
 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

 # Specify how to extract privacy_id, partition_key, and value from a   
 # single element.
 data_extractors = pipeline_dp.DataExtractors(
     partition_extractor=lambda row: row.product_view_0,
     privacy_id_extractor=lambda row: row.user_id)

 # Run aggregation.
 dp_result = dp_engine.select_partitions(
     data, pipeline_dp.SelectPrivatePartitionsParams(
       max_partitions_contributed=1),
     data_extractors=data_extractors)

 budget_accountant.compute_budgets()
 return dp_result

6. Вычислите множественные статистические показатели.

Теперь, когда вы знаете, как работает PipelineDP, вы можете увидеть, как его можно использовать в более сложных сценариях. Как упоминалось в начале, вас интересуют три статистических показателя. PipelineDP позволяет вычислять несколько показателей одновременно, если они имеют одинаковые параметры в экземпляре AggregateParams , который вы увидите позже. Это не только удобнее и проще, но и обеспечивает лучшую конфиденциальность при одновременном вычислении нескольких метрик.

Если вы помните параметры epsilon и delta , которые вы передаете классу NaiveBudgetAccountant , они представляют собой так называемый бюджет конфиденциальности , который измеряет степень утечки конфиденциальной информации о пользователе из данных.

Важно помнить, что бюджет конфиденциальности является аддитивным. Если вы запускаете конвейер с определенным значением эпсилон ε и дельта δ один раз, вы израсходуете бюджет (ε,δ). Если вы запустите его второй раз, вы израсходуете общий бюджет (2ε, 2δ). Аналогично, если вы вычисляете несколько статистических показателей с помощью метода NaiveBudgetAccountant и последовательно используете бюджет конфиденциальности ε,δ, вы израсходуете общий бюджет (2ε, 2δ). Это означает, что вы ухудшаете гарантии конфиденциальности.

Чтобы обойти это ограничение, необходимо использовать один экземпляр NaiveBudgetAccountant с общим бюджетом, который вы хотите использовать при вычислении нескольких статистических показателей для одних и тех же данных. Затем вам нужно указать значения epsilon и delta , которые вы хотите использовать для каждой агрегации. В итоге вы получаете ту же общую гарантию конфиденциальности, но чем выше значения epsilon и delta у конкретной агрегации, тем выше ее точность.

Чтобы увидеть это в действии, вы можете вычислить статистические показатели: count , mean и sum .

Вы рассчитываете статистику на основе двух разных показателей: показателя conversion_value , который используется для определения объема дохода в зависимости от того, какой продукт был просмотрен первым, и показателя has_conversion , который используется для расчета количества посетителей вашего сайта и среднего коэффициента конверсии.

Для каждой метрики необходимо отдельно указать параметры, которые определяют расчет статистики конфиденциальности. Вы распределяете свой бюджет конфиденциальности между двумя метриками. Вы рассчитываете две статистики на основе метрики has_conversion , поэтому вам нужно выделить ей две трети вашего первоначального бюджета, а оставшуюся одну треть — на метрику conversion_value .

Для вычисления нескольких статистических показателей:

1. Настройте свой бухгалтер по бюджету конфиденциальности, указав суммарные значения epsilon и delta , которые вы хотите использовать для трех статистических показателей:

budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=0)

2. Инициализируйте DPEngine для расчета ваших метрик:

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

3. Укажите параметры для этой метрики.

params_conversion_value_metrics = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.SUM],
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     min_value=0,
     max_value=100,
     public_partitions=public_partitions,
     budget_weight=1/3)

Последний аргумент необязательно задает вес вашего бюджета конфиденциальности. Вы можете присвоить одинаковый вес всем параметрам, но, как объяснялось ранее, лучше установить этот аргумент на одну треть.

Также вы можете задать аргументы min_value и max_value , чтобы указать нижнюю и верхнюю границы, применяемые к значению, вносимому единицей конфиденциальности в раздел. Эти параметры необходимы, если вы хотите вычислить сумму или среднее значение конфиденциальности. Отрицательных значений не ожидается, поэтому вы можете считать 0 и 100 разумными границами.

4. Извлеките необходимые данные и передайте их в функцию агрегирования:

data_extractors_conversion_value_metrics = pipeline_dp.DataExtractors(
     privacy_id_extractor=lambda row: row.user_id,
     partition_extractor=lambda row: row.product_view_0,
     value_extractor=lambda row: row.conversion_value)

 dp_result_conversion_value_metrics = (
     dp_engine.aggregate(data, params_conversion_value_metrics,
         data_extractors_conversion_value_metrics))

5. Выполните те же шаги для расчета двух показателей на основе вашей переменной has_conversion :

params_conversion_rate_metrics = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT, pipeline_dp.Metrics.MEAN],
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     min_value=0,
     max_value=1,
     public_partitions=public_partitions,
     budget_weight=2/3)

 data_extractors_conversion_rate_metrics = pipeline_dp.DataExtractors(
     privacy_id_extractor=lambda row: row.user_id,
     partition_extractor=lambda row: row.product_view_0,
     value_extractor=lambda row: row.has_conversion)

 dp_result_conversion_rate_metrics = (
     dp_engine.aggregate(data, params_conversion_rate_metrics,
         data_extractors_conversion_rate_metrics))

Единственное изменение касается экземпляра pipeline_dp.AggregateParams , в котором теперь вы определяете mean и count как агрегированные показатели и выделяете две трети вашего бюджета конфиденциальности на этот расчет. Поскольку вы хотите иметь одинаковые границы вклада для обеих статистических показателей и рассчитывать их на основе одной и той же переменной has_conversion , вы можете объединить их в одном экземпляре pipeline_dp.AggregateParams и рассчитать одновременно.

6. Вызовите метод budget_accountant.compute_budgets() :

budget_accountant.compute_budgets()

Вы можете построить графики всех трех частных статистических показателей в сравнении с их исходными показателями. В зависимости от добавленного шума, вы увидите, что результаты могут фактически выходить за пределы правдоподобной шкалы. В этом случае вы видите отрицательный коэффициент конверсии и общую стоимость конверсии для прыгунов, поскольку добавленный шум симметричен относительно нуля. Для дальнейшего анализа и обработки лучше не обрабатывать частные статистические данные вручную, но если вы хотите добавить эти графики в отчет, вы можете просто установить минимальное значение равным нулю после этого, не нарушая гарантий конфиденциальности.

7. Запустите конвейер с помощью Beam.

В наши дни обработка данных требует работы с огромными объемами информации, настолько большими, что обрабатывать их локально невозможно. Вместо этого многие используют фреймворки для обработки больших объемов данных, такие как Beam или Spark, и запускают свои конвейеры в облаке.

PipelineDP поддерживает Beam и Spark, требуя лишь незначительных изменений в вашем коде.

Для запуска конвейера с использованием Beam и API private_beam :

1. Инициализируйте переменную runner , а затем создайте конвейер, в котором вы будете применять операции обеспечения конфиденциальности к представлению rows в формате Beam:

runner = fn_api_runner.FnApiRunner()  # local runner

with beam.Pipeline(runner=runner) as pipeline:
   beam_data = pipeline | beam.Create(rows)

2. Создайте переменную budget_accountant с необходимыми параметрами конфиденциальности:

budget_accountant = pipeline_dp.NaiveBudgetAccountant(
               total_epsilon=1, total_delta=0)

3. Создайте переменную типа pcol , или "приватная коллекция", которая гарантирует соответствие любых агрегаций вашим требованиям конфиденциальности:

pcol = beam_data | pbeam.MakePrivate(
                                 budget_accountant=budget_accountant,
                                 privacy_id_extractor=lambda 
                                                    row: row.user_id)

4. Укажите параметры вашей частной агрегации в соответствующем классе.

Здесь используется класс pipeline_dp.aggregate_params.SumParams() , поскольку он вычисляет сумму просмотров товаров.

5. Передайте параметры агрегации методу pbeam.Sum для вычисления статистики:

dp_result = pcol | pbeam.Sum(params)

6. В итоге ваш код должен выглядеть примерно так:

import pipeline_dp.private_beam as pbeam
runner = fn_api_runner.FnApiRunner()  # local runner

with beam.Pipeline(runner=runner) as pipeline:
   beam_data = pipeline | beam.Create(rows)
   budget_accountant = pipeline_dp.NaiveBudgetAccountant(
               total_epsilon=1, total_delta=0)

   # Create private collection.
   pcol = beam_data | pbeam.MakePrivate(
                              budget_accountant=budget_accountant,
                              privacy_id_extractor=lambda row:  
                                                         row.user_id)
   # Specify parameters.
   params = pipeline_dp.aggregate_params.SumParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     max_partitions_contributed=1,
     max_contributions_per_partition=1,
     min_value=0,
     max_value=100,
     public_partitions=public_partitions_product_views,
     partition_extractor=lambda row: row.product_view_0,
     value_extractor=lambda row:row.conversion_value)
   dp_result = pcol | pbeam.Sum(params)

   budget_accountant.compute_budgets()
   dp_result | beam.Map(print)

8. Дополнительно: Настройте параметры конфиденциальности и полезности.

В этом практическом задании вы уже встречали довольно много параметров, таких как epsilon , delta и max_partitions_contributed . Их можно условно разделить на две категории: параметры конфиденциальности и параметры полезности .

Параметры конфиденциальности

Параметры epsilon и delta количественно определяют уровень конфиденциальности, обеспечиваемый дифференциальной конфиденциальностью. Точнее, они измеряют, сколько информации потенциальный злоумышленник может получить о данных из анонимизированного результата. Чем выше значение параметров, тем больше информации получает злоумышленник о данных, что представляет собой риск для конфиденциальности. С другой стороны, чем ниже значения параметров epsilon и delta , тем больше шума необходимо добавить в результат, чтобы сделать его анонимным, и тем больше уникальных пользователей необходимо в каждом разделе, чтобы сохранить их в анонимизированном результате. В этом случае возникает компромисс между полезностью и конфиденциальностью.

В PipelineDP необходимо указать желаемые гарантии конфиденциальности анонимизированных данных при установке общего бюджета конфиденциальности в экземпляре NaiveBudgetAccountant . Следует помнить, что для обеспечения соблюдения гарантий конфиденциальности необходимо использовать отдельный экземпляр NaiveBudgetAccountant для каждой агрегации или запускать конвейер несколько раз, чтобы избежать перерасхода бюджета.

Для получения дополнительной информации о дифференциальной конфиденциальности и значении параметров конфиденциальности см. список литературы по дифференциальной конфиденциальности .

Параметры полезности

Параметры полезности не влияют на гарантии конфиденциальности, но влияют на точность и, следовательно, на полезность выходных данных. Они предоставляются в экземпляре AggregateParams и используются для масштабирования добавляемого шума.

Параметр max_partitions_contributed предоставляемый в экземпляре AggregateParams и применимый ко всем агрегациям, является вспомогательным параметром. Раздел соответствует ключу данных, возвращаемых операцией агрегации PipelineDP, поэтому параметр max_partitions_contributed ограничивает количество различных значений ключей, которые пользователь может добавить в выходные данные. Если пользователь добавляет значения ключей, превышающие значение параметра max_partitions_contributed , некоторые добавления отбрасываются, так что они добавляют значения, равные точному значению параметра max_partitions_contributed .

Аналогично, большинство агрегаций имеют параметр max_contributions_per_partition . Он также предоставляется в экземпляре AggregateParams , и каждая агрегация может иметь для него отдельные значения. Он ограничивает вклад пользователя для каждого ключа.

Уровень шума, добавляемого к выходным данным, масштабируется параметрами max_partitions_contributed и max_contributions_per_partition , поэтому здесь есть компромисс: чем больше значений присвоено каждому параметру, тем больше данных сохраняется, но тем больше шума в результате.

Для некоторых агрегаций требуются параметры min_value и max_value , которые определяют границы вклада каждого пользователя. Если пользователь вносит значение меньше значения, присвоенного параметру min_value , значение увеличивается до значения этого параметра. Аналогично, если пользователь вносит значение больше значения параметра max_value , значение уменьшается до значения этого параметра. Чтобы сохранить больше исходных значений, необходимо указать более широкие границы. Шум масштабируется размером границ, поэтому более широкие границы позволяют сохранить больше данных, но в итоге результат получается более зашумленным.

Наконец, параметр noise_kind поддерживает два различных механизма шума в PipelineDP: GAUSSIAN и LAPLACE распределение. LAPLACE распределение обеспечивает лучшую эффективность при низких границах вклада, поэтому PipelineDP использует его по умолчанию. Однако, если вы хотите использовать шум GAUSSIAN распределения, вы можете указать его в экземпляре AggregateParams .

9. Поздравляем!

Отличная работа! Вы завершили практическое занятие по PipelineDP и много узнали о дифференциальной конфиденциальности и PipelineDP.

Узнать больше

• Репозиторий GitHub
• PipelineDP
• Кодлаборатория по обеспечению конфиденциальности в Beam