Calculer des statistiques privées avec PipelineDP

1. Avant de commencer

Vous pensez peut-être que les statistiques agrégées ne divulguent aucune information sur les personnes concernées. Cependant, les pirates informatiques connaissent différents moyens pour obtenir des informations sensibles sur les personnes à partir de statistiques agrégées.

Dans cet atelier de programmation, vous allez apprendre à générer des statistiques privées à l'aide d'agrégations différentiellement privées à partir de PipelineDP pour protéger la confidentialité des personnes. PipelineDP est un framework Python qui vous permet d'appliquer la confidentialité différentielle à de grands ensembles de données avec des systèmes de traitement par lot, tels qu'Apache Spark et Apache Beam. Pour savoir comment calculer des statistiques différentiellement privées en Go, consultez l'atelier de programmation Privacy on Beam.

Privé signifie que la sortie est générée de manière à ne pas divulguer d'informations privées sur les personnes concernées par les données. Pour ce faire, vous pouvez utiliser la confidentialité différentielle, une notion de l'anonymisation qui protège fortement la confidentialité. L'anonymisation est le processus d'agrégation des données de plusieurs utilisateurs afin de protéger leur confidentialité. Si toutes les méthodes d'anonymisation utilisent l'agrégation, toutes les méthodes d'agrégation n'aboutissent pas à une anonymisation. La confidentialité différentielle, quant à elle, offre des garanties mesurables concernant les fuites d'informations et la confidentialité.

Prérequis

• Connaissance de Python
• Connaissance de l'agrégation de données de base
• Expérience avec pandas, Spark et Beam

Points abordés

• Principes de base de la confidentialité différentielle
• Calculer des statistiques récapitulatives différentiellement privées avec PipelineDP
• Ajuster vos résultats avec des paramètres supplémentaires de confidentialité et d'utilité

Prérequis

• Si vous souhaitez exécuter l'atelier de programmation dans votre propre environnement, vous devez installer Python 3.7 ou une version ultérieure sur votre ordinateur.
• Si vous souhaitez suivre l'atelier de programmation sans votre propre environnement, vous devez avoir accès à Colaboratory.

2. Comprendre la confidentialité différentielle

Pour mieux comprendre la confidentialité différentielle, prenons un exemple simple.

Imaginez que vous travaillez dans le service marketing d'un marchand de mode en ligne et que vous souhaitez identifier les produits les plus susceptibles de se vendre.

Ce graphique indique les produits que les clients ont regardés en premier lorsqu'ils ont visité le site Web de la boutique : t-shirts, pulls, chaussettes ou jeans. Les T-shirts sont les articles les plus populaires, tandis que les chaussettes le sont le moins.

Cela semble utile, mais il y a un bémol. Si vous souhaitez prendre en compte des informations supplémentaires, comme le fait de savoir si les clients ont effectué un achat ou quel produit ils ont consulté en deuxième, vous risquez de révéler des informations sur des personnes dans vos données.

Ce graphique montre qu'un seul client a d'abord regardé un pull, puis l'a acheté :

Ce graphique n'est pas idéal en termes de confidentialité. Les statistiques anonymisées ne doivent pas révéler de contributions individuelles. Que faire dans ce cas ? Vous ajoutez un bruit aléatoire à vos graphiques à barres pour réduire légèrement leur précision.

Ce graphique à barres n'est pas totalement exact, mais il reste utile et il ne dévoile aucune contribution individuelle :

La confidentialité différentielle consiste à ajouter la bonne quantité de bruit aléatoire afin de masquer les contributions individuelles.

Cet exemple est trop simpliste. La mise en place d'une confidentialité différentielle nécessite un peu plus de travail et présente plusieurs subtilités. Comme pour la cryptographie, il n'est pas forcément judicieux de chercher à développer sa propre solution de confidentialité différentielle. Vous pouvez utiliser PipelineDP à la place.

3. Télécharger et installer PipelineDP

Vous n'avez pas besoin d'installer PipelineDP pour suivre cet atelier de programmation, car vous trouverez tous les codes et graphiques pertinents dans ce document.

Pour tester PipelineDP, l'exécuter vous-même ou l'utiliser ultérieurement :

• Téléchargez et installez PipelineDP :

pip install pipeline-dp

Si vous souhaitez exécuter l'exemple à l'aide d'Apache Beam :

• Téléchargez et installez Apache Beam :

pip install apache_beam

Le code de cet atelier de programmation et l'ensemble de données se trouvent dans le répertoire PipelineDP/examples/codelab/.

4. Calculer les métriques de conversion par premier produit consulté

Imaginez que vous travaillez pour un marchand de vêtements en ligne et que vous souhaitez identifier les catégories de produits qui génèrent le plus de conversions (en nombre et en valeur) lorsqu'elles sont consultées en premier. Vous souhaitez partager ces informations avec votre agence marketing et d'autres équipes internes, mais vous voulez éviter de divulguer des informations sur des clients spécifiques.

Pour calculer les métriques de conversion par premier produit consulté pour le site Web :

1. Examinez l'ensemble de données fictif des visites sur votre site Web dans le répertoire PipelineDP/examples/codelab/.

Cette capture d'écran est un exemple de l'ensemble de données. Il contient l'ID de l'utilisateur, les produits qu'il a consultés, s'il a effectué une conversion et, le cas échéant, la valeur de la conversion.

user_id	product_view_0	product_view_1	product_view_2	product_view_3	product_view_4	has_conversion	conversion_value
0	Jeans	t_shirt	t_shirt	aucun	aucun	faux	0,0
1	Jeans	t_shirt	Jeans	jumper	aucun	faux	0,0
2	t_shirt	jumper	t_shirt	t_shirt	aucun	true	105,19
3	t_shirt	t_shirt	Jeans	aucun	aucun	faux	0,0
4	t_shirt	chaussettes	Jeans	Jeans	aucun	faux	0,0

Vous vous intéressez à ces métriques :

• view_counts : nombre de fois où les visiteurs de votre site Web voient chaque produit en premier.
• total_conversion_value : montant total dépensé par les visiteurs lorsqu'ils effectuent une conversion.
• conversion_rate : taux de conversion des visiteurs.

2. Générez les métriques de manière non privée :

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)

Comme vous l'avez appris précédemment, ces statistiques peuvent révéler des informations sur les personnes figurant dans votre ensemble de données. Par exemple, une seule personne a effectué une conversion après avoir vu un pull en premier. Pour 22 vues, votre taux de conversion est d'environ 0,05. Vous devez maintenant transformer chaque graphique à barres en graphique privé.

3. Définissez vos paramètres de confidentialité avec la classe pipeline_dp.NaiveBudgetAccountant, puis spécifiez les arguments epsilon et delta que vous souhaitez utiliser pour votre analyse.

La façon dont vous définissez ces arguments dépend de votre problème spécifique. Pour en savoir plus, consultez "Facultatif : Ajuster les paramètres de confidentialité différentielle".

Cet extrait de code utilise des exemples de valeurs :

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

4. Initialisez l'instance LocalBackend :

ops = pipeline_dp.LocalBackend()

Vous pouvez utiliser l'instance LocalBackend, car vous exécutez ce programme en local sans frameworks supplémentaires, tels que Beam ou Spark.

5. Initialisez l'instance DPEngine :

dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

PipelineDP vous permet de spécifier d'autres paramètres via la classe pipeline_dp.AggregateParams, ce qui affecte la génération de vos statistiques privées.

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. Indiquez que vous souhaitez calculer la métrique count et utiliser la distribution du bruit LAPLACE.
7. Définissez l'argument max_partitions_contributed sur une valeur 1.

Cet argument limite le nombre de visites différentes auxquelles un utilisateur peut contribuer. Vous vous attendez à ce que les utilisateurs visitent le site Web une fois par jour, et vous ne vous souciez pas de savoir s'ils le visitent plusieurs fois au cours de la journée.

8. Définissez l'argument max_contributions_per_partitions sur une valeur 1.

Cet argument spécifie le nombre de contributions qu'un même visiteur peut apporter à une partition ou à une catégorie de produits.

9. Créez une instance data_extractor qui spécifie où trouver les champs privacy_id, partition et value.

Votre code devrait se présenter comme suit :

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. Ajoutez ce code pour transformer votre DataFrame Pandas en une liste de lignes à partir desquelles vous pouvez calculer directement des statistiques avec confidentialité différentielle :

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

Félicitations ! Vous avez calculé votre première statistique différentiellement privée.

Ce graphique montre le résultat de votre nombre différentiellement privé à côté du nombre non privé que vous avez calculé précédemment :

Le graphique à barres obtenu lorsque vous exécutez le code peut être différent de celui présenté ci-dessous. C'est normal. En raison du bruit lié à la confidentialité différentielle, vous obtenez un graphique à barres différent chaque fois que vous exécutez le code, mais vous pouvez constater qu'ils sont tous similaires au graphique à barres d'origine non privé.

Pour que les garanties de confidentialité soient respectées, il est essentiel de ne pas exécuter le pipeline à plusieurs reprises. Pour en savoir plus, consultez "Calculer plusieurs statistiques".

5. Utiliser des partitions publiques

Dans la section précédente, vous avez peut-être remarqué que vous avez supprimé toutes les données de visites d'une partition, à savoir les visiteurs qui ont vu des chaussettes pour la première fois sur votre site Web.

Cela est dû à la sélection des partitions ou à la mise en place d'un seuil. Cette étape est importante pour respecter les garanties de confidentialité différentielle lorsque l'existence de partitions de sortie dépend des données utilisateur elles-mêmes. Lorsque c'est le cas, la simple existence d'une partition dans la sortie peut dévoiler l'existence d'un utilisateur spécifique dans les données. Pour en savoir plus sur les raisons pour lesquelles cela constitue une atteinte à la confidentialité, consultez cet article de blog. Pour éviter cette atteinte à la confidentialité, PipelineDP ne conserve que les partitions contenant un nombre suffisant d'utilisateurs.

Lorsque la liste des partitions de sortie ne dépend pas d'informations privées sur les utilisateurs, cette étape de sélection des partitions n'est pas requise. C'est le cas pour votre exemple, car vous connaissez toutes les catégories de produits possibles qu'un client peut voir en premier.

Pour utiliser des partitions :

1. Créez une liste de vos partitions possibles :

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

2. Transmettez la liste à la fonction run_pipeline(), qui la définit comme entrée supplémentaire de la classe 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)

Si vous utilisez des partitions publiques et un bruit LAPLACE, vous pouvez définir l'argument total_delta sur une valeur 0.

Vous pouvez maintenant voir dans le résultat que les données de toutes les partitions ou de tous les produits sont signalées.

Non seulement les partitions publiques vous permettent de conserver plus de partitions, mais elles ajoutent aussi environ la moitié du bruit, puisque vous ne dépensez aucun budget de confidentialité pour la sélection de partitions. La différence entre les chiffres bruts et les chiffres privés est donc légèrement moindre que lors de l'exécution précédente.

Lorsque vous utilisez des partitions publiques, tenez compte de deux points importants :

• Soyez prudent lorsque vous déduisez la liste des partitions à partir des données brutes. Si vous n'appliquez pas de méthode différentiellement privée, votre pipeline ne respecte plus les garanties de confidentialité différentielle. Pour en savoir plus, consultez "Avancé : Dériver des partitions à partir de données".
• En l'absence de données pour certaines des partitions publiques, vous devez appliquer du bruit à ces partitions afin de préserver la confidentialité différentielle. Par exemple, si vous avez utilisé un produit supplémentaire comme un pantalon, qui n'apparaît pas dans votre ensemble de données ni sur votre site Web, il s'agit toujours de bruit. Les résultats peuvent alors indiquer des visites de produits alors qu'il n'y en a pas eu.

Avancé : Déduire des partitions à partir des données

Si vous exécutez plusieurs agrégations avec la même liste de partitions de sortie non publiques dans le même pipeline, vous pouvez déduire la liste des partitions une fois avec la méthode dp_engine.select_private_partitions() et fournir les partitions à chaque agrégation comme entrée public_partitions. C'est non seulement parfaitement sûr du point de vue de la confidentialité, mais cela vous permet également d'ajouter moins de bruit, car vous ne consommez votre budget de confidentialité qu'une seule fois pour l'ensemble du pipeline lors de la sélection des 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. Calculer plusieurs statistiques

Maintenant que vous savez comment fonctionne PipelineDP, vous pouvez découvrir comment l'utiliser pour des cas d'utilisation plus avancés. Comme mentionné au début, vous vous intéressez à trois statistiques. PipelineDP vous permet de calculer plusieurs statistiques en même temps, à condition qu'elles partagent les mêmes paramètres dans l'instance AggregateParams, que vous verrez plus tard. Il est non seulement plus clair et plus facile de calculer plusieurs métriques en une seule fois, mais c'est également préférable en termes de confidentialité.

Souvenez-vous des paramètres epsilon et delta que vous fournissez à la classe NaiveBudgetAccountant : ils représentent un budget de confidentialité, qui correspond à la proportion de confidentialité de chaque utilisateur que vous divulguez dans les données.

N'oubliez pas que ce budget de confidentialité s'additionne. Si vous exécutez un pipeline avec des valeurs epsilon ε et delta δ spécifiques une fois, vous dépensez un budget de (ε,δ). Si vous l'exécutez une deuxième fois, le budget total dépensé est de (2ε, 2δ). De même, si vous calculez plusieurs statistiques avec une méthode NaiveBudgetAccountant et un budget de confidentialité de ε,δ, le budget total dépensé est de (2ε, 2δ). Vous dégradez donc les garanties de confidentialité.

Pour contourner ce problème, vous devez utiliser une seule instance NaiveBudgetAccountant avec le budget total que vous souhaitez utiliser lorsque vous devez calculer plusieurs statistiques sur les mêmes données. Vous devez ensuite spécifier les valeurs epsilon et delta que vous souhaitez utiliser pour chaque agrégation. Au final, vous vous retrouverez avec la même garantie de confidentialité globale, mais plus les valeurs epsilon et delta d'une agrégation donnée sont élevées, plus le résultat sera précis.

Pour voir une démonstration, vous pouvez calculer les statistiques count, mean et sum.

Vous calculez des statistiques sur la base de deux métriques différentes : une métrique conversion_value, que vous utilisez pour déduire le montant des revenus générés en fonction du produit consulté en premier, et une métrique has_conversion, que vous utilisez pour calculer le nombre de visiteurs de votre site Web et le taux de conversion moyen.

Pour chaque métrique, vous devez spécifier séparément les paramètres qui guident le calcul des statistiques privées. Vous répartissez votre budget de confidentialité entre les deux métriques. Vous calculez deux statistiques à partir de la métrique has_conversion. Vous devez donc lui attribuer les deux tiers de votre budget initial et attribuer l'autre tiers à la métrique conversion_value.

Pour calculer plusieurs statistiques :

1. Configurez votre comptable du budget de confidentialité avec les valeurs totales epsilon et delta que vous souhaitez utiliser pour les trois statistiques :

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

2. Initialisez DPEngine pour calculer vos métriques :

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

3. Spécifiez les paramètres de cette métrique.

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)

Le dernier argument spécifie éventuellement le poids de votre budget de confidentialité. Vous pouvez attribuer le même poids à tous les éléments, mais vous devez définir cet argument sur un tiers, comme expliqué précédemment.

Vous définissez également un argument min_value et max_value pour spécifier les limites inférieure et supérieure appliquées à une valeur fournie par une unité de confidentialité dans une partition. Ces paramètres sont obligatoires lorsque vous souhaitez calculer une somme ou une moyenne privées. Vous ne vous attendez pas à des valeurs négatives. Vous pouvez donc supposer que 0 et 100 sont des limites raisonnables.

4. Extrayez les données pertinentes, puis transmettez-les à la fonction d'agrégation :

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. Suivez les mêmes étapes pour calculer les deux métriques en fonction de votre variable 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))

La seule modification concerne l'instance pipeline_dp.AggregateParams, dans laquelle vous définissez désormais mean et count comme des agrégations, et vous attribuez les deux tiers de votre budget de confidentialité à ce calcul. Comme vous souhaitez que les limites de contribution soient les mêmes pour les deux statistiques et les calculer sur la même variable has_conversion, vous pouvez les combiner dans la même instance pipeline_dp.AggregateParams et les calculer en même temps.

6. Appelez la méthode budget_accountant.compute_budgets() :

budget_accountant.compute_budgets()

Vous pouvez représenter graphiquement les trois statistiques privées en les comparant à leurs statistiques d'origine. En fonction du bruit ajouté, vous pouvez constater que les résultats peuvent en fait sortir de l'échelle plausible. Dans ce cas, vous constaterez un taux de conversion et une valeur de conversion totaux négatifs pour les jumpers, car le bruit ajouté est symétrique autour de zéro. Pour d'autres analyses et traitements, il est préférable de ne pas post-traiter manuellement les statistiques privées. Toutefois, si vous souhaitez ajouter ces graphiques à un rapport, vous pouvez simplement définir le minimum sur zéro par la suite, sans enfreindre les garanties de confidentialité.

7. Exécuter le pipeline avec Beam

De nos jours, le traitement des données nécessite de gérer d'énormes quantités de données, à tel point qu'il est impossible de les traiter localement. Au lieu de cela, de nombreuses personnes utilisent des frameworks pour le traitement de données à grande échelle, tels que Beam ou Spark, et exécutent leurs pipelines dans le cloud.

PipelineDP est compatible avec Beam et Spark, et ne nécessite que de légères modifications de votre code.

Pour exécuter le pipeline avec Beam et l'API private_beam :

1. Initialisez une variable runner, puis créez un pipeline dans lequel vous appliquez vos opérations de confidentialité à une représentation Beam de votre rows :

runner = fn_api_runner.FnApiRunner()  # local runner

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

2. Créez une variable budget_accountant avec les paramètres de confidentialité requis :

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

3. Créez une variable pcol ou de collection privée, qui garantit que toutes les agrégations sont conformes à vos exigences en matière de confidentialité :

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

4. Spécifiez les paramètres de votre agrégation privée dans la classe appropriée.

Ici, vous utilisez la classe pipeline_dp.aggregate_params.SumParams(), car vous calculez la somme des vues de produits.

5. Transmettez vos paramètres d'agrégation à la méthode pbeam.Sum pour calculer votre statistique :

dp_result = pcol | pbeam.Sum(params)

6. Au final, voici comment devrait se présenter votre code :

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. Facultatif : Ajustez les paramètres de confidentialité et d'utilité.

Différents paramètres ont été mentionnés dans cet atelier de programmation, comme les paramètres epsilon, delta et max_partitions_contributed. Ils se répartissent en deux grandes catégories : les paramètres de confidentialité et les paramètres utilitaires.

Paramètres de confidentialité

Les paramètres epsilon et delta quantifient la confidentialité que vous fournissez avec la confidentialité différentielle. Plus précisément, ils mesurent la quantité d'informations qu'un pirate informatique potentiel pourrait obtenir concernant les données à partir de la sortie anonymisée. Plus la valeur des paramètres est élevée, plus le pirate informatique peut obtenir d'informations sur les données, avec à la clé un risque pour la confidentialité des données. À l'opposé, plus les valeurs des paramètres epsilon et delta sont faibles, plus vous devez ajouter de bruit à la sortie pour l'anonymiser, et plus le nombre d'utilisateurs uniques dans chaque partition doit être élevé pour que la partition puisse être conservée dans le résultat anonymisé. Dans ce cas, il existe un compromis entre utilité et confidentialité.

Dans PipelineDP, vous devez spécifier les garanties de confidentialité souhaitées pour votre résultat anonymisé lorsque vous définissez le budget total de confidentialité dans l'instance NaiveBudgetAccountant. Si vous souhaitez que vos garanties de confidentialité soient respectées, vous devez utiliser avec précaution une instance NaiveBudgetAccountant distincte pour chaque agrégation ou exécuter le pipeline à plusieurs reprises afin d'éviter de surconsommer votre budget.

Pour en savoir plus sur la confidentialité différentielle et sur la signification des paramètres de confidentialité, consultez la liste de lecture sur la confidentialité différentielle.

Paramètres utilitaires

Les paramètres d'utilité n'ont aucune incidence sur les garanties de confidentialité, mais ils influent sur la précision et donc sur l'utilité du résultat. Ils sont fournis dans l'instance AggregateParams et permettent d'ajuster le bruit ajouté.

max_partitions_contributed fait partie des paramètres utilitaires fournis dans l'instance AggregateParams et applicables à toutes les agrégations. Une partition correspond à une clé des données renvoyées par l'opération d'agrégation PipelineDP. Le paramètre max_partitions_contributed limite donc le nombre de valeurs clés distinctes auxquelles un utilisateur peut contribuer dans le résultat. Si un utilisateur contribue à un nombre de clés supérieur à la valeur du paramètre max_partitions_contributed, certaines contributions sont supprimées afin qu'il contribue exactement à la valeur du paramètre max_partitions_contributed.

De même, la plupart des agrégations comportent un paramètre max_contributions_per_partition. Elles sont également fournies dans l'instance AggregateParams, et chaque agrégation peut avoir des valeurs distinctes. Elles limitent la contribution d'un utilisateur pour chaque clé.

Le bruit ajouté à la sortie est ajusté par les paramètres max_partitions_contributed et max_contributions_per_partition, moyennant un compromis : plus les valeurs attribuées à chaque paramètre sont élevées, plus vous conservez de données, mais vous obtenez un résultat plus bruyant.

Certaines agrégations nécessitent des paramètres min_value et max_value, qui spécifient les limites des contributions de chaque utilisateur. Si un utilisateur contribue à une valeur inférieure à celle attribuée au paramètre min_value, la valeur est augmentée pour correspondre à celle du paramètre. De même, si un utilisateur contribue à une valeur supérieure à celle du paramètre max_value, la valeur est réduite à celle du paramètre. Pour conserver davantage de valeurs d'origine, vous devez élargir les limites. Le bruit est ajusté en fonction de la taille des limites : plus les limites sont larges, plus vous conservez de données, mais vous vous retrouverez alors avec plus de bruit dans les résultats.

Enfin, le paramètre noise_kind accepte deux mécanismes de bruit différents dans PipelineDP : le bruit GAUSSIAN et le bruit LAPLACE. La distribution LAPLACE est plus efficace avec les limites de contribution faibles, c'est pourquoi PipelineDP l'utilise par défaut. Toutefois, si vous souhaitez utiliser un bruit à distribution GAUSSIAN, vous pouvez le spécifier dans l'instance AggregateParams.

9. Félicitations

Bravo ! Vous avez terminé l'atelier de programmation PipelineDP et en avez beaucoup appris sur la confidentialité différentielle et PipelineDP.

En savoir plus

• Dépôt GitHub
• PipelineDP
• Atelier de programmation sur la confidentialité sur Beam