Calcola statistiche private con PipelineDP

1. Prima di iniziare

Potresti ritenere che le statistiche aggregate non trasmettano alcuna informazione sulle persone a cui si riferiscono. Tuttavia, esistono molti modi in cui un aggressore può apprendere informazioni sensibili sugli individui dalle statistiche aggregate.

In questo codelab, imparerai come produrre statistiche private con aggregazioni differenziate rispetto a PipelineDP per proteggere le persone privacy. PipelineDP è un framework Python che consente di applicare la privacy differenziale a grandi set di dati con sistemi di elaborazione batch, come Apache Spark e Apache Beam. Per ulteriori informazioni su come calcolare statistiche differenziate sulla privacy in Go, consulta il codelab Privacy su Beam.

Privato significa che l'output è prodotto in modo da non divulgare informazioni private sulle persone incluse nei dati. Puoi ottenere questo risultato attraverso la privacy differenziale, una solida nozione di privacy di anonimizzazione, ovvero il processo di aggregazione dei dati tra più utenti per proteggere la privacy degli utenti. Tutti i metodi di anonimizzazione utilizzano l'aggregazione, ma non tutti i metodi ottengono l'anonimizzazione. La privacy differenziale, d'altra parte, fornisce garanzie misurabili sulla fuga di informazioni e sulla privacy.

Prerequisiti

• Dimestichezza con Python
• Dimestichezza con l'aggregazione di dati di base
• Esperienza con panda, Spark e Beam

Obiettivi didattici

• Nozioni di base sulla privacy differenziale
• Come calcolare statistiche di riepilogo private in modo differenziato con PipelineDP
• Come modificare i risultati con parametri aggiuntivi di privacy e utilità

Che cosa ti serve

• Se vuoi eseguire il codelab nel tuo ambiente, devi avere installato sul computer Python 3.7 o versioni successive.
• Se vuoi seguire il codelab senza il tuo ambiente, devi accedere a Colaboratory.

2. Informazioni sulla privacy differenziale

Per comprendere meglio la privacy differenziale, guarda questo semplice esempio.

Immagina di lavorare nel reparto marketing di un rivenditore di moda online e di voler capire quali dei tuoi prodotti hanno maggiori probabilità di vendere.

Questo grafico mostra i prodotti che i clienti hanno guardato per primi quando hanno visitato il sito web del negozio: t-shirt, maglioni, calze o jeans. Le t-shirt sono l'articolo più popolare, mentre i calzini sono l'articolo meno popolare.

Sembra utile, ma c'è un problema. Quando vuoi prendere in considerazione informazioni aggiuntive, ad esempio se i clienti hanno effettuato un acquisto o quale prodotto hanno visualizzato per secondo, rischi di rivelare le persone nei tuoi dati.

Questo grafico mostra che solo un cliente ha guardato prima un ponticello e poi ha effettivamente effettuato un acquisto:

Non è un'ottima cosa dal punto di vista della privacy. Le statistiche anonimizzate non devono rivelare i contributi individuali, quindi cosa fai? Aggiungi rumore casuale ai tuoi grafici a barre per renderli un po' meno precisi.

Questo grafico a barre non è completamente preciso, ma è comunque utile e non rivela i singoli contributi:

La privacy differenziale è l'aggiunta della giusta quantità di rumore casuale per mascherare i singoli contributi.

Questo esempio è eccessivamente semplificato. La corretta implementazione della privacy differenziale è più complessa e comporta una serie di sottigliezze di implementazione impreviste. Come per la crittografia, potrebbe non essere una buona idea creare una tua implementazione della privacy differenziale. Puoi usare invece PipelineDP.

3. Scarica e installa PipelineDP

Non è necessario installare PipelineDP. Segui questo codelab perché puoi trovare tutto il codice e i grafici pertinenti in questo documento.

Per sperimentare con PipelineDP, eseguilo autonomamente o usalo in un secondo momento:

• Scarica e installa PipelineDP:

pip install pipeline-dp

Se vuoi eseguire l'esempio utilizzando Apache Beam:

• Scarica e installa Apache Beam:

pip install apache_beam

Puoi trovare il codice per questo codelab e il set di dati nella directory PipelineDP/examples/codelab/.

4. Calcola le metriche di conversione per il primo prodotto visualizzato

Immagina di lavorare presso un rivenditore di moda online e di voler capire quali delle diverse categorie di prodotti generano il numero e il valore più elevati di conversioni quando visualizzate per prime. Vuoi condividere queste informazioni con la tua agenzia di marketing e con altri team interni, ma vuoi evitare la fuga di informazioni su singoli clienti.

Per calcolare le metriche di conversione per il primo prodotto visualizzato per il sito web:

1. Esamina il set di dati fittizio delle visite al tuo sito web nella directory PipelineDP/examples/codelab/.

Questo screenshot è un esempio del set di dati. Contiene l'ID utente, i prodotti che un utente ha visualizzato, se il visitatore ha effettuato una conversione e, in tal caso, il valore della conversione.

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	nessuno	nessuno	falso	0.0
1	jeans	t_shirt	jeans	ponticello	nessuno	falso	0.0
2	t_shirt	ponticello	t_shirt	t_shirt	nessuno	true	105,19
3	t_shirt	t_shirt	jeans	nessuno	nessuno	falso	0.0
4	t_shirt	calzini	jeans	jeans	nessuno	falso	0.0

Ti interessano le seguenti metriche:

• view_counts: il numero di volte in cui i visitatori del tuo sito web visualizzano per primo ciascun prodotto.
• total_conversion_value: l'importo totale che i visitatori spendono quando effettuano una conversione.
• conversion_rate: la frequenza con cui i visitatori effettuano una conversione.

2. Genera le metriche in modo non privato:

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)

Come hai appreso in precedenza, queste statistiche possono rivelare informazioni su persone nel tuo set di dati. Ad esempio, solo una persona ha effettuato la conversione dopo aver visto prima un ponticello. Per 22 visualizzazioni, il tasso di conversione è di circa 0,05. Ora devi trasformare ogni grafico a barre in uno privato.

3. Definisci i parametri di privacy con la classe pipeline_dp.NaiveBudgetAccountant, quindi specifica gli argomenti epsilon e delta che vuoi utilizzare per l'analisi.

Il modo in cui imposti questi argomenti dipende dal problema specifico. Per ulteriori informazioni in merito, vedi (Facoltativo) Regolare i parametri di privacy differenziale.

Questo snippet di codice utilizza valori di esempio:

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

4. Inizializza l'istanza LocalBackend:

ops = pipeline_dp.LocalBackend()

Puoi utilizzare l'istanza LocalBackend perché esegui questo programma localmente senza framework aggiuntivi, come Beam o Spark.

5. Inizializza l'istanza DPEngine:

dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

PipelineDP consente di specificare ulteriori parametri tramite la classe pipeline_dp.AggregateParams, che influisce sulla generazione delle statistiche private.

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. Specifica che vuoi calcolare la metrica count e utilizzare la distribuzione del rumore LAPLACE.
7. Imposta l'argomento max_partitions_contributed su un valore 1.

Questo argomento limita il numero di visite diverse che un utente può contribuire. Ti aspetti che gli utenti visitino il sito web una volta al giorno e non ti importa se lo visitano più volte nel corso della giornata.

8. Imposta l'argomento max_contributions_per_partitions su un valore 1.

Questo argomento specifica il numero di contributi che un singolo visitatore può apportare a una singola partizione o a una categoria di prodotto in questo caso.

9. Crea un'istanza data_extractor che specifichi dove trovare i campi privacy_id, partition e value.

Il tuo codice dovrebbe essere simile al seguente snippet di codice:

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. Aggiungi questo codice per trasformare il DataFrame Pandas in un elenco di righe da cui puoi calcolare direttamente statistiche differenzialmente private:

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

Complimenti! Hai calcolato la tua prima statistica differenziata.

Questo grafico mostra il risultato del conteggio differenzialmente privato accanto al conteggio dei contenuti non privati che hai calcolato in precedenza:

Il grafico a barre visualizzato quando esegui il codice potrebbe essere diverso da questo, il che va bene. A causa del rumore nella privacy differenziale, ogni volta che esegui il codice viene visualizzato un grafico a barre diverso, ma come puoi notare sono simili al grafico a barre originale non privato.

Tieni presente che è molto importante che le garanzie sulla privacy non eseguano la pipeline più volte per garantire la privacy. Per ulteriori informazioni, consulta Calcola più statistiche.

5. Usa partizioni pubbliche

Nella sezione precedente, potresti aver notato che hai eliminato tutti i dati sulle visite per una partizione, ovvero i visitatori che hanno visto per la prima volta le calze sul tuo sito web.

Ciò è dovuto alla selezione o soglia delle partizioni, un passaggio importante per garantire garanzie di privacy differenziale quando l'esistenza delle partizioni di output dipende dai dati utente stessi. In questo caso, la sola esistenza di una partizione nell'output può far trapelare l'esistenza di un singolo utente nei dati. Per scoprire di più sul motivo per cui ciò rappresenta una violazione della privacy, leggi questo post del blog. Per evitare questa violazione della privacy, PipelineDP conserva solo le partizioni con un numero sufficiente di utenti al loro interno.

Quando l'elenco delle partizioni di output non dipende da dati utente privati, questo passaggio di selezione della partizione non è necessario. Questo è il caso del tuo esempio, perché conosci tutte le possibili categorie di prodotto che un cliente potrebbe vedere per prime.

Per utilizzare le partizioni:

1. Crea un elenco delle partizioni possibili:

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

2. Passa l'elenco alla funzione run_pipeline(), che lo imposta come input aggiuntivo per 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)

Se utilizzi partizioni pubbliche e rumore LAPLACE, è possibile impostare l'argomento total_delta su un valore 0.

Nel risultato ora puoi vedere che vengono riportati i dati di tutte le partizioni o prodotti.

Le partizioni pubbliche non solo ti consentono di conservare più partizioni, ma aggiungono anche circa la metà del rumore perché non viene speso alcun budget di privacy per la selezione delle partizioni, quindi la differenza tra i conteggi non elaborati e privati è leggermente inferiore rispetto all'esecuzione precedente.

Quando utilizzi le partizioni pubbliche, tieni presente due importanti aspetti:

• Fai attenzione quando ricava l'elenco delle partizioni da dati non elaborati. Se non lo fai in modo differenziato, la tua pipeline non fornirà più garanzie di privacy differenziale. Per ulteriori informazioni, vedi Avanzato: estrarre le partizioni dai dati.
• Se non sono disponibili dati per alcune partizioni pubbliche, devi applicare rumore a queste partizioni per preservare la privacy differenziale. Ad esempio, se hai utilizzato un prodotto aggiuntivo come i pantaloni, che non compare nel tuo set di dati o sul tuo sito web, c'è ancora rumore e i risultati potrebbero mostrare alcune visite a prodotti quando non ce ne sono.

Impostazioni avanzate: estrarre partizioni dai dati

Se esegui più aggregazioni con lo stesso elenco di partizioni di output non pubbliche nella stessa pipeline, puoi ricavare l'elenco delle partizioni una volta con il metodo dp_engine.select_private_partitions() e fornire le partizioni a ogni aggregazione come input public_partitions. Non solo è sicuro dal punto di vista della privacy, ma ti consente anche di aggiungere meno rumore perché utilizzi il budget relativo alla privacy solo una volta per l'intera pipeline.

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. Calcola più statistiche

Ora che sai come funziona PipelineDP, puoi vedere come puoi utilizzarlo per alcuni casi d'uso più avanzati. Come accennato all'inizio, sei interessato a tre statistiche. PipelineDP consente di calcolare più statistiche contemporaneamente, purché condividano gli stessi parametri nell'istanza AggregateParams, che vedrai più avanti. Oltre a semplificare il calcolo di più metriche contemporaneamente, è più semplice e lineare, ma è anche più efficiente in termini di privacy.

Se ricordi i parametri epsilon e delta che fornisci alla classe NaiveBudgetAccountant, rappresentano un cosiddetto budget per la privacy, che è una misura della quantità di privacy dell'utente divulgata dai dati.

Una cosa importante da ricordare sul budget per la privacy è che è cumulativo. Se esegui una pipeline con una particolare epsilon ↂ e delta ♦ una sola volta, spendi un budget (Π, ). Se lo esegui una seconda volta, spenderai un budget totale di (2Π, 2elaborazione). Allo stesso modo, se calcoli più statistiche con un metodo NaiveBudgetAccountant e consecutivamente un budget di privacy di Φ, Ciò significa che le garanzie sulla privacy vengono ridotte.

Per aggirare questo problema, devi utilizzare una singola istanza NaiveBudgetAccountant con il budget totale da utilizzare quando devi calcolare più statistiche sugli stessi dati. Devi quindi specificare i valori epsilon e delta che vuoi utilizzare per ogni aggregazione. In ultima analisi, ottieni la stessa garanzia di privacy complessiva, ma più elevati sono i valori epsilon e delta di una determinata aggregazione, maggiore sarà l'accuratezza.

Per vedere un esempio pratico, puoi calcolare le statistiche count, mean e sum.

Le statistiche vengono calcolate in base a due diverse metriche: una metrica conversion_value, che utilizzi per dedurre l'importo delle entrate generate in base al prodotto visualizzato per primo, e una metrica has_conversion, che utilizzi per calcolare il numero di visitatori del tuo sito web e il tasso di conversione medio.

Per ogni metrica, devi specificare separatamente i parametri che guidano il calcolo delle statistiche private. Devi suddividere il budget per la privacy tra le due metriche. Crei due statistiche in base alla metrica has_conversion, quindi assegnale due terzi del budget iniziale e l'altro terzo alla metrica conversion_value.

Per calcolare più statistiche:

1. Imposta la contabilità del budget per la privacy con i valori totali di epsilon e delta che vuoi utilizzare nelle tre statistiche:

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

2. Inizializza il DPEngine per calcolare le metriche:

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

3. Specifica i parametri per questa metrica.

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)

L'ultimo argomento specifica facoltativamente il peso del budget per la privacy. Potreste assegnare lo stesso peso a tutti, ma impostare questo argomento su un terzo, come spiegato in precedenza.

Puoi anche impostare un argomento min_value e max_value per specificare il limite inferiore e quello superiore applicati a un valore apportato da un'unità di privacy in una partizione. Questi parametri sono obbligatori per calcolare una somma o una media privata. Non prevedi valori negativi, quindi puoi presupporre 0 e 100 come limiti ragionevoli.

4. Estrai i dati pertinenti e poi passali alla funzione di aggregazione:

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. Segui gli stessi passaggi per calcolare le due metriche in base alla variabile 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))

L'unica modifica riguarda l'istanza pipeline_dp.AggregateParams, in cui ora definisci mean e count come aggregazioni e assegni due terzi del budget di privacy a questo calcolo. Poiché vuoi avere gli stessi limiti di contributo per entrambe le statistiche e calcolarli in base alla stessa variabile has_conversion, puoi combinarli nella stessa istanza pipeline_dp.AggregateParams e calcolarli contemporaneamente.

6. Chiama il metodo budget_accountant.compute_budgets():

budget_accountant.compute_budgets()

Puoi rappresentare tutte e tre le statistiche private confrontandole con le statistiche originali. A seconda del rumore aggiunto, vedrai che i risultati possono effettivamente non rientrare nella scala plausibile. In questo caso, il tasso di conversione e il valore di conversione totale sono negativi, perché il rumore aggiunto è simmetrico attorno allo zero. Per ulteriori analisi ed elaborazioni, è preferibile non post-elaborare manualmente le statistiche private, ma se volessi aggiungere questi grafici a un report, potresti semplicemente impostare il minimo su zero in seguito, senza violazione delle garanzie sulla privacy.

7. esegui la pipeline con Beam

L'elaborazione dei dati oggi richiede la gestione di enormi quantità di dati da non poterle elaborare localmente. Molte persone utilizzano invece framework per l'elaborazione dati su larga scala, come Beam o Spark, ed eseguono le proprie pipeline nel cloud.

PipelineDP supporta Beam e Spark con piccole modifiche al codice.

Per eseguire la pipeline con Beam con l'API private_beam:

1. Inizializza una variabile runner e crea una pipeline in cui applicare le operazioni sulla privacy a una rappresentazione Beam di rows:

runner = fn_api_runner.FnApiRunner()  # local runner

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

2. Crea una variabile budget_accountant con i parametri di privacy richiesti:

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

3. Crea una variabile pcol, o raccolta privata, che garantisca che tutte le aggregazioni siano conformi ai tuoi requisiti di privacy:

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

4. Specifica i parametri dell'aggregazione privata nella classe appropriata.

Qui usi la classe pipeline_dp.aggregate_params.SumParams() perché calcoli la somma delle visualizzazioni dei prodotti.

5. Passa i parametri di aggregazione al metodo pbeam.Sum per calcolare le statistiche:

dp_result = pcol | pbeam.Sum(params)

6. Alla fine, il tuo codice dovrebbe essere simile al seguente snippet di codice:

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. (Facoltativo) Modificare i parametri di privacy e utilità

Hai visto un bel po' di parametri menzionati in questo codelab, ad esempio i parametri epsilon, delta e max_partitions_contributed. Puoi suddividerli in due categorie indicativamente: parametri privacy e parametri di utilità.

Parametri privacy

I parametri epsilon e delta quantificano la privacy che fornisci con la privacy differenziale. Più precisamente, si tratta di una misura di quante informazioni può ottenere un potenziale aggressore sui dati provenienti da un output anonimo. Più alto è il valore dei parametri, maggiori sono le informazioni sui dati che l'aggressore ottiene, con un rischio per la privacy. D'altra parte, più basso è il valore dei parametri epsilon e delta, maggiore è il rumore da aggiungere all'output per renderlo anonimo e più alto è il numero di utenti unici necessari in ogni partizione per mantenerli nell'output anonimo. In questo caso, occorre trovare un compromesso tra utilità e privacy.

In PipelineDP, devi specificare le garanzie di privacy desiderate per l'output anonimo quando imposti il budget totale della privacy nell'istanza NaiveBudgetAccountant. Tieni presente che, se vuoi che le tue garanzie di privacy vengano mantenute, devi utilizzare con attenzione un'istanza NaiveBudgetAccountant separata per ogni aggregazione o eseguire la pipeline più volte per evitare un uso eccessivo del budget.

Per ulteriori informazioni sulla privacy differenziale e sul significato dei parametri di privacy, consulta Un elenco di lettura sulla privacy differenziale.

Parametri utilità

I parametri di utilità non influiscono sulle garanzie della privacy, ma influiscono sull'accuratezza e, di conseguenza, sull'utilità dell'output. Vengono forniti nell'istanza AggregateParams e utilizzati per scalare il rumore aggiunto.

Un parametro di utilità fornito nell'istanza AggregateParams e applicabile a tutte le aggregazioni è il parametro max_partitions_contributed. Una partizione corrisponde a una chiave dei dati restituiti dall'operazione di aggregazione PipelineDP, quindi il parametro max_partitions_contributed limita il numero di coppie chiave-valore distinti che un utente può contribuire all'output. Se un utente contribuisce per un numero di chiavi superiore al valore del parametro max_partitions_contributed, alcuni contributi vengono eliminati in modo da contribuire al valore esatto del parametro max_partitions_contributed.

Allo stesso modo, la maggior parte delle aggregazioni ha un parametro max_contributions_per_partition. Sono forniti anche nell'istanza AggregateParams e ogni aggregazione potrebbe avere valori separati. associano il contributo di un utente a ogni chiave.

Il rumore aggiunto all'output viene scalato dai parametri max_partitions_contributed e max_contributions_per_partition, quindi c'è un compromesso: valori più alti assegnati a ciascun parametro significano che vengono conservati più dati, ma il risultato è più rumoroso.

Alcune aggregazioni richiedono i parametri min_value e max_value, che specificano i limiti per i contributi di ciascun utente. Se un utente contribuisce con un valore inferiore a quello assegnato al parametro min_value, il valore viene aumentato al valore del parametro. In modo analogo, se un utente contribuisce con un valore superiore a quello del parametro max_value, il valore viene diminuito al valore del parametro. Per conservare un numero maggiore di valori originali, devi specificare limiti maggiori. Il rumore viene scalato in base alla dimensione dei limiti, quindi limiti più ampi ti consentono di conservare più dati, ma il risultato sarà più rumoroso.

Infine, il parametro noise_kind supporta due diversi meccanismi di rumore in PipelineDP: GAUSSIAN e LAPLACE di rumore. La distribuzione LAPLACE offre un'utilità migliore con limiti di contributo bassi, motivo per cui PipelineDP la utilizza per impostazione predefinita. Tuttavia, se vuoi utilizzare un rumore di distribuzione GAUSSIAN, puoi specificarlo nell'istanza AggregateParams.

9. Complimenti

Ottimo lavoro. Hai terminato il codelab PipelineDP e hai appreso molto sulla privacy differenziale e su PipelineDP.

Scopri di più

• Repository GitHub
• PipelineDP
• Codelab sulla privacy su Beam