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

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

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

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

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

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

• Знакомство с Питоном
• Знание основ агрегирования данных
• Опыт работы с 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 и используются для масштабирования добавляемого шума.

Параметр утилиты, предоставленный в экземпляре AggregateParams и применимый ко всем агрегатам, — это параметр max_partitions_contributed . Секция соответствует ключу данных, возвращаемых операцией агрегации 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
• ТрубопроводDP
• Конфиденциальность в кодовой лаборатории Beam