Menghitung statistik pribadi dengan PipelineDP

1. Sebelum memulai

Anda mungkin berpikir bahwa statistik gabungan tidak akan membocorkan informasi individu yang dikumpulkan datanya. Namun, ada banyak cara penyerang dapat mempelajari informasi sensitif seseorang dari statistik gabungan.

Dalam codelab ini, Anda akan mempelajari cara menghasilkan statistik pribadi dengan agregasi pribadi lain dari PipelineDP untuk melindungi privasi individu. PipelineDP adalah framework Python yang memungkinkan Anda menerapkan privasi diferensial ke set data besar dengan sistem pemrosesan batch, seperti Apache Spark dan Apache Beam. Untuk mengetahui informasi selengkapnya tentang cara menghitung statistik privasi diferensial di Go, lihat codelab Privacy on Beam.

Pribadi berarti output dihasilkan dengan cara yang tidak akan membocorkan informasi pribadi individu dalam data. Anda dapat mencapai hasil ini melalui privasi diferensial, yaitu suatu gagasan privasi yang kuat untuk anonimisasi, yang merupakan proses penggabungan data di beberapa pengguna untuk melindungi privasi pengguna. Semua metode anonimisasi menggunakan agregasi, tetapi tidak semua metode agregasi mencapai level anonimisasi. Di sisi lain, privasi diferensial memberikan jaminan terukur tentang kebocoran informasi dan privasi.

Prasyarat

  • Memahami Python
  • Pemahaman tentang agregasi data dasar
  • Pengalaman dengan pandas, Spark, dan Beam

Yang akan Anda pelajari

  • Dasar-dasar privasi diferensial
  • Cara menghitung statistik ringkasan privasi diferensial dengan PipelineDP
  • Cara menyesuaikan hasil Anda dengan parameter privasi dan kegunaan tambahan

Yang Anda butuhkan

  • Jika ingin menjalankan codelab di lingkungan Anda sendiri, Anda harus menginstal Python 3.7 atau yang lebih tinggi di komputer Anda.
  • Jika ingin mengikuti codelab tanpa lingkungan Anda sendiri, Anda memerlukan akses ke Colaboratory.

2. Memahami privasi diferensial

Untuk lebih memahami privasi diferensial, lihat contoh sederhana ini.

Bayangkan Anda bekerja di departemen pemasaran retailer mode online dan ingin memahami produk mana yang kemungkinan besar akan terjual.

Diagram ini menunjukkan produk mana yang pertama kali dilihat pelanggan saat mereka mengunjungi situs toko: t-shirt, jumper, kaus kaki, atau celana jeans. Kaos adalah item yang paling populer, sedangkan kaus kaki adalah item yang paling tidak populer.

ea813c698889a4c6.png

Ini terlihat berguna, tetapi ada syaratnya. Jika Anda ingin mempertimbangkan informasi tambahan, seperti apakah pelanggan melakukan pembelian atau produk mana yang mereka lihat kedua, Anda berisiko mengungkapkan identitas individu dalam data Anda.

Diagram ini menunjukkan bahwa hanya satu pelanggan yang melihat jumper terlebih dahulu, lalu benar-benar melakukan pembelian:

b7c6f7f891778366.png

Ini jelas tidak bagus dari sudut pandang privasi. Statistik anonim tidak boleh mengungkapkan kontribusi individu, jadi apa yang harus Anda lakukan? Anda menambahkan derau acak ke diagram batang untuk membuatnya sedikit kurang akurat.

Diagram batang ini tidak sepenuhnya akurat, tetapi tetap berguna dan tidak mengungkapkan kontribusi individu:

b55e8d7f99f6d574.gif

Privasi diferensial adalah penambahan jumlah derau acak yang tepat untuk menyamarkan kontribusi individual.

Contoh ini terlalu disederhanakan. Penerapan privasi diferensial yang tepat lebih terlibat dan memiliki sejumlah seluk-beluk penerapan yang tidak terduga. Serupa dengan kriptografi, membuat penerapan privasi diferensial Anda sendiri mungkin bukan ide yang bagus. Sebagai gantinya, Anda dapat menggunakan PipelineDP.

3. Mendownload dan menginstal PipelineDP

Anda tidak perlu menginstal PipelineDP untuk mengikuti codelab ini karena Anda dapat menemukan semua kode dan grafik yang relevan dalam dokumen ini.

Untuk bereksperimen dengan PipelineDP, jalankan sendiri, atau gunakan nanti:

  • Download dan instal PipelineDP:
pip install pipeline-dp

Jika Anda ingin menjalankan contoh menggunakan Apache Beam:

  • Download dan instal Apache Beam:
pip install apache_beam

Anda dapat menemukan kode untuk codelab ini dan set data di direktori PipelineDP/examples/codelab/.

4. Menghitung metrik konversi per produk pertama yang dilihat

Bayangkan Anda bekerja di retailer mode online dan ingin memahami kategori produk mana yang menghasilkan jumlah dan nilai konversi tertinggi saat pertama kali dilihat. Anda ingin membagikan informasi ini kepada agensi pemasaran Anda serta tim internal lainnya, tetapi Anda ingin mencegah kebocoran informasi tentang setiap pelanggan.

Untuk menghitung metrik konversi per produk pertama yang dilihat untuk situs:

  1. Tinjau set data tiruan kunjungan ke situs Anda di direktori PipelineDP/examples/codelab/.

Screenshot ini adalah contoh set data. Data ini berisi ID pengguna, produk yang dilihat pengguna, apakah pengunjung melakukan konversi, dan jika ya, nilai konversinya.

user_id

product_view_0

product_view_1

product_view_2

product_view_3

product_view_4

has_conversion

conversion_value

0

celana jins

t_shirt

t_shirt

tidak ada

tidak ada

false

0,0

1

celana jins

t_shirt

celana jins

jumper

tidak ada

false

0,0

2

t_shirt

jumper

t_shirt

t_shirt

tidak ada

true

105,19

3

t_shirt

t_shirt

celana jins

tidak ada

tidak ada

false

0,0

4

t_shirt

kaus kaki

celana jins

celana jins

tidak ada

false

0,0

Anda tertarik dengan metrik ini:

  • view_counts: Jumlah berapa kali pengunjung situs Anda melihat setiap produk untuk pertama kalinya.
  • total_conversion_value: Jumlah total uang yang dibelanjakan pengunjung saat mereka melakukan konversi.
  • conversion_rate: Kecepatan konversi pengunjung.
  1. Buat metrik dengan cara non-pribadi:
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)

Seperti yang Anda pelajari sebelumnya, statistik ini dapat mengungkapkan informasi tentang individu dalam set data Anda. Misalnya, hanya satu orang yang melakukan konversi setelah orang tersebut melihat iklan pelompat terlebih dahulu. Untuk 22 penayangan, rasio konversi Anda adalah sekitar 0,05. Sekarang Anda perlu mengubah setiap diagram batang menjadi diagram batang pribadi.

  1. Tentukan parameter privasi Anda dengan class pipeline_dp.NaiveBudgetAccountant, lalu tentukan argumen epsilon dan delta yang ingin Anda gunakan untuk analisis.

Cara Anda menetapkan argumen ini bergantung pada masalah khusus Anda. Untuk mempelajari lebih lanjut, lihat Opsional: Sesuaikan parameter privasi diferensial.

Cuplikan kode ini menggunakan nilai contoh:

budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=1e-5)
  1. Lakukan inisialisasi instance LocalBackend:
ops = pipeline_dp.LocalBackend()

Anda dapat menggunakan instance LocalBackend karena Anda menjalankan program ini secara lokal tanpa framework tambahan, seperti Beam atau Spark.

  1. Lakukan inisialisasi instance DPEngine:
dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

PipelineDP memungkinkan Anda menentukan parameter lebih lanjut melalui class pipeline_dp.AggregateParams, yang memengaruhi pembuatan statistik pribadi Anda.

params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1,
     max_contributions_per_partition=1)
  1. Tentukan bahwa Anda ingin menghitung metrik count dan menggunakan distribusi derau LAPLACE.
  2. Tetapkan argumen max_partitions_contributed ke nilai 1.

Argumen ini membatasi jumlah kunjungan berbeda yang dapat dikontribusikan oleh pengguna. Anda berharap pengguna mengunjungi situs sekali per hari dan Anda tidak peduli apakah mereka mengunjungi situs beberapa kali sepanjang hari.

  1. Tetapkan argumen max_contributions_per_partitions ke nilai 1.

Argumen ini menentukan jumlah kontribusi yang dapat dilakukan satu pengunjung ke partisi tertentu atau kategori produk dalam kasus ini.

  1. Buat instance data_extractor yang menentukan tempat untuk menemukan kolom privacy_id, partition, dan value.

Kode Anda akan terlihat seperti cuplikan kode ini:

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
  1. Tambahkan kode ini untuk mengubah Pandas DataFrame Anda menjadi daftar baris yang dapat Anda gunakan untuk menghitung statistik privasi diferensial secara langsung:
rows = [index_row[1] for index_row in df.iterrows()]
dp_result_local = run_pipeline(rows, ops) # Returns generator
list(dp_result_local)

Selamat! Anda telah menghitung statistik khusus pribadi pertama Anda!

Diagram ini menunjukkan hasil penghitungan khusus pribadi Anda di samping penghitungan non-pribadi yang Anda hitung sebelumnya:

a5a25a00858219ab.png

Diagram batang yang Anda dapatkan saat menjalankan kode mungkin berbeda dari yang ini, dan itu tidak masalah. Karena derau dalam privasi diferensial, Anda akan mendapatkan diagram batang yang berbeda setiap kali menjalankan kode, tetapi Anda dapat melihat bahwa diagram tersebut mirip dengan diagram batang non-pribadi asli.

Perlu diperhatikan bahwa sangat penting bagi jaminan privasi untuk tidak menjalankan pipeline beberapa kali demi jaminan privasi. Untuk mengetahui informasi selengkapnya, lihat Menghitung beberapa statistik.

5. Menggunakan partisi publik

Di bagian sebelumnya, Anda mungkin melihat bahwa Anda telah menghapus semua data kunjungan untuk partisi, yaitu pengunjung yang pertama kali melihat kaus kaki di situs Anda.

Hal ini terjadi karena pemilihan atau penentuan ambang batas partisi, yang merupakan langkah penting untuk memastikan jaminan privasi diferensial ketika keberadaan partisi output bergantung pada data pengguna itu sendiri. Jika hal ini terjadi, keberadaan partisi di output dapat membocorkan keberadaan pengguna individual dalam data. Untuk mempelajari lebih lanjut alasan hal ini melanggar privasi, lihat postingan blog ini. Untuk mencegah pelanggaran privasi ini, PipelineDP hanya menyimpan partisi dengan jumlah pengguna yang mencukupi.

Jika daftar partisi output tidak bergantung pada data pengguna pribadi, Anda tidak memerlukan langkah pemilihan partisi ini. Hal ini sebenarnya terjadi pada contoh Anda karena Anda mengetahui semua kemungkinan kategori produk yang dapat dilihat pelanggan terlebih dahulu.

Untuk menggunakan partisi:

  1. Buat daftar kemungkinan partisi Anda:
public_partitions_products = ['jeans', 'jumper', 'socks', 't-shirt']
  1. Teruskan daftar ke fungsi run_pipeline(), yang menetapkannya sebagai input tambahan ke class 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)

Jika Anda menggunakan partisi publik dan derau LAPLACE, Anda dapat menyetel argumen total_delta ke nilai 0.

Sekarang Anda dapat melihat dalam hasil bahwa data untuk semua partisi, atau produk, dilaporkan.

a4f6302c8efcd5da.png

Partisi publik tidak hanya memungkinkan Anda menyimpan lebih banyak partisi, tetapi juga menambahkan kurang lebih setengah derau karena Anda tidak membelanjakan persediaan privasi pada pemilihan partisi, sehingga perbedaan antara jumlah mentah dan pribadi cenderung lebih sedikit dibandingkan dengan proses sebelumnya.

Ada dua hal penting yang perlu diingat saat Anda menggunakan partisi publik:

  • Berhati-hatilah saat Anda menempatkan daftar partisi dari data mentah. Jika Anda tidak melakukannya dengan cara privasi diferensial, pipeline Anda tidak lagi memberikan jaminan privasi diferensial. Untuk mengetahui informasi selengkapnya, lihat Lanjutan: Mendapatkan partisi dari data.
  • Jika tidak ada data untuk beberapa partisi publik, Anda perlu menerapkan derau ke partisi tersebut untuk mempertahankan privasi diferensial. Misalnya, jika Anda menggunakan produk tambahan seperti celana panjang, yang tidak ada dalam set data atau di situs Anda, hal ini tetap dianggap sebagai derau dan hasilnya mungkin menunjukkan beberapa kunjungan ke produk padahal tidak ada.

Lanjutan: Mengambil partisi dari data

Jika menjalankan beberapa agregasi dengan daftar partisi output non-publik yang sama dalam pipeline yang sama, Anda dapat memperoleh daftar partisi satu kali dengan metode dp_engine.select_private_partitions() dan memasukkan partisi ke setiap agregasi sebagai input public_partitions. Selain aman dari segi privasi, fitur ini juga memungkinkan Anda menambahkan lebih sedikit derau karena Anda hanya menggunakan persediaan privasi pada pemilihan partisi sekali untuk seluruh 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. Menghitung beberapa statistik

Setelah mengetahui cara kerja PipelineDP, Anda dapat melihat cara menggunakannya untuk beberapa kasus penggunaan yang lebih canggih. Seperti yang disebutkan di awal, Anda tertarik dengan tiga statistik. PipelineDP memungkinkan Anda menghitung beberapa statistik secara bersamaan selama statistik tersebut berbagi parameter yang sama dalam instance AggregateParams, yang akan Anda lihat nanti. Selain lebih bersih dan mudah untuk menghitung beberapa metrik sekaligus, cara ini juga lebih baik dalam hal privasi.

Jika Anda mengingat parameter epsilon dan delta yang Anda berikan ke class NaiveBudgetAccountant, parameter tersebut mewakili persediaan privasi, yang merupakan ukuran jumlah privasi pengguna yang Anda bocorkan dari data.

Hal penting yang harus diingat tentang persediaan privasi adalah bahwa persediaan bersifat aditif. Jika Anda menjalankan pipeline dengan epsilon ε dan delta δ hanya satu kali, Anda menghabiskan persediaan (ε,δ). Jika menjalankannya untuk kedua kalinya, Anda akan membelanjakan total anggaran sebesar (2ε, 2δ). Demikian pula, jika Anda menghitung beberapa statistik dengan metode NaiveBudgetAccountant dan secara berurutan memiliki anggaran privasi sebesar ε,δ, Anda membelanjakan total anggaran (2ε, 2δ). Ini berarti Anda menurunkan jaminan privasi.

Untuk mengatasi hal ini, Anda harus menggunakan satu instance NaiveBudgetAccountant dengan total anggaran yang ingin digunakan saat Anda perlu menghitung beberapa statistik pada data yang sama. Kemudian, Anda perlu menentukan nilai epsilon dan delta yang ingin digunakan untuk setiap agregasi. Pada akhirnya, Anda akan mendapatkan jaminan privasi yang sama secara keseluruhan, tetapi makin tinggi nilai epsilon dan delta yang dimiliki agregasi tertentu, makin tinggi akurasinya.

Untuk melihatnya beraksi, Anda dapat menghitung statistik count, mean, dan sum.

Anda menghitung statistik berdasarkan dua metrik yang berbeda: metrik conversion_value, yang Anda gunakan untuk menyimpulkan jumlah pendapatan yang dihasilkan berdasarkan produk mana yang dilihat terlebih dahulu, dan metrik has_conversion, yang Anda gunakan untuk menghitung jumlah pengunjung ke situs Anda dan rasio konversi rata-rata.

Untuk setiap metrik, Anda harus menentukan parameter yang memandu penghitungan statistik pribadi secara terpisah. Anda membagi anggaran privasi di antara dua metrik. Anda menghitung dua statistik dari metrik has_conversion, jadi Anda ingin mengalokasikan dua pertiga dari anggaran awal Anda untuk metrik tersebut dan mengalokasikan sepertiga lainnya untuk metrik conversion_value.

Untuk menghitung beberapa statistik:

  1. Siapkan akuntan anggaran privasi Anda dengan total nilai epsilon dan delta yang ingin Anda gunakan di ketiga statistik:
budget_accountant = pipeline_dp.NaiveBudgetAccountant(
     total_epsilon=1, total_delta=0)
  1. Lakukan inisialisasi DPEngine untuk menghitung metrik Anda:
 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)
  1. Tentukan parameter untuk metrik ini.
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)

Argumen terakhir secara opsional menentukan bobot anggaran privasi Anda. Anda dapat memberikan bobot yang sama untuk semuanya, tetapi Anda ingin menyetel argumen ini menjadi sepertiga seperti yang dijelaskan sebelumnya.

Anda juga menetapkan argumen min_value dan max_value untuk menentukan batas bawah dan atas yang diterapkan pada nilai yang diberikan oleh unit privasi dalam partisi. Parameter ini diperlukan jika Anda ingin menghitung jumlah atau rata-rata pribadi. Anda tidak mengharapkan nilai negatif, jadi Anda dapat mengasumsikan 0 dan 100 sebagai batas yang wajar.

  1. Ekstrak data yang relevan, lalu teruskan ke fungsi agregasi:
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))
  1. Ikuti langkah-langkah yang sama untuk menghitung kedua metrik berdasarkan variabel 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))

Satu-satunya perubahan ada pada instance pipeline_dp.AggregateParams, yang kini Anda tetapkan mean dan count sebagai agregasi, dan menetapkan dua pertiga anggaran privasi Anda untuk penghitungan ini. Karena Anda ingin memiliki batas kontribusi yang sama untuk kedua statistik dan menghitungnya di atas variabel has_conversion yang sama, Anda dapat menggabungkannya dalam instance pipeline_dp.AggregateParams yang sama dan menghitungnya secara bersamaan.

  1. Panggil metode budget_accountant.compute_budgets():
budget_accountant.compute_budgets()

Anda dapat memetakan ketiga statistik pribadi dalam perbandingan dengan statistik aslinya. Bergantung pada derau yang ditambahkan, Anda dapat melihat bahwa hasilnya dapat berada di luar skala yang masuk akal. Dalam contoh ini, Anda melihat rasio konversi negatif dan total nilai konversi untuk pelompat karena derau yang ditambahkan simetris di sekitar nol. Untuk analisis dan pemrosesan lebih lanjut, sebaiknya jangan memproses statistik pribadi secara manual setelahnya, tetapi jika Anda ingin menambahkan plot tersebut ke laporan, Anda cukup menyetel minimum ke nol setelahnya tanpa melanggar jaminan privasi.

cb1fc563f817eaf.png

7. Menjalankan pipeline dengan Beam

Pemrosesan data saat ini mengharuskan Anda menangani data dalam jumlah besar, sehingga Anda tidak dapat memprosesnya secara lokal. Sebagai gantinya, banyak orang menggunakan framework untuk pemrosesan data berskala besar, seperti Beam atau Spark, dan menjalankan pipeline mereka di cloud.

PipelineDP mendukung Beam dan Spark hanya dengan sedikit perubahan pada kode Anda.

Untuk menjalankan pipeline dengan Beam menggunakan API private_beam:

  1. Lakukan inisialisasi variabel runner, lalu buat pipeline tempat Anda menerapkan operasi privasi ke representasi Beam dari rows Anda:
runner = fn_api_runner.FnApiRunner()  # local runner

with beam.Pipeline(runner=runner) as pipeline:
   beam_data = pipeline | beam.Create(rows)
  1. Buat variabel budget_accountant dengan parameter privasi yang diperlukan:
budget_accountant = pipeline_dp.NaiveBudgetAccountant(
               total_epsilon=1, total_delta=0)
  1. Buat variabel pcol, atau koleksi pribadi, yang menjamin bahwa setiap penggabungan sesuai dengan persyaratan privasi Anda:
pcol = beam_data | pbeam.MakePrivate(
                                 budget_accountant=budget_accountant,
                                 privacy_id_extractor=lambda 
                                                    row: row.user_id)
  1. Tentukan parameter agregasi pribadi Anda di class yang sesuai.

Di sini, Anda menggunakan class pipeline_dp.aggregate_params.SumParams() karena Anda menghitung jumlah penayangan produk.

  1. Teruskan parameter agregasi ke metode pbeam.Sum untuk menghitung statistik:
dp_result = pcol | pbeam.Sum(params)
  1. Pada akhirnya, kode Anda akan terlihat seperti cuplikan kode ini:
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. Opsional: Menyesuaikan parameter privasi dan utilitas

Anda telah melihat beberapa parameter yang disebutkan dalam codelab ini, seperti parameter epsilon, delta, dan max_partitions_contributed. Anda dapat membaginya secara kasar menjadi dua kategori: parameter privasi dan parameter utilitas.

Parameter privasi

Parameter epsilon dan delta mengukur privasi yang Anda berikan dengan privasi diferensial. Lebih tepatnya, nilai ini adalah ukuran seberapa banyak informasi yang dapat diperoleh penyerang potensial tentang data dari output anonim. Makin tinggi nilai parameter, makin banyak informasi yang diperoleh penyerang tentang data, dan merupakan risiko privasi. Di sisi lain, makin rendah nilai parameter epsilon dan delta, makin banyak derau yang harus Anda tambahkan ke output agar menjadi anonim dan makin tinggi jumlah pengguna unik yang Anda perlukan di setiap partisi untuk mempertahankan partisi tersebut tetap menjadi output anonimisasi. Dalam hal ini, ada konsekuensi antara utilitas dan privasi.

Di PipelineDP, Anda perlu menentukan jaminan privasi yang diinginkan untuk output anonimisasi saat menetapkan total persediaan privasi dalam instance NaiveBudgetAccountant. Masalahnya adalah jika ingin jaminan privasi tetap berlaku, Anda harus menggunakan instance NaiveBudgetAccountant terpisah dengan hati-hati untuk setiap agregasi atau menjalankan pipeline beberapa kali untuk menghindari penggunaan berlebihan anggaran Anda.

Untuk mengetahui informasi selengkapnya tentang privasi diferensial dan arti parameter privasi, lihat Daftar bacaan tentang privasi diferensial.

Parameter utilitas

Parameter utilitas tidak memengaruhi jaminan privasi, tetapi memengaruhi akurasi dan, akibatnya, kegunaan output. Nilai ini disediakan dalam instance AggregateParams dan digunakan untuk menskalakan derau yang ditambahkan.

Parameter utilitas yang disediakan di instance AggregateParams dan berlaku untuk semua agregasi adalah parameter max_partitions_contributed. Partisi sesuai dengan kunci data yang ditampilkan oleh operasi agregasi PipelineDP, sehingga parameter max_partitions_contributed membatasi jumlah nilai kunci berbeda yang dapat dikontribusikan pengguna ke output. Jika pengguna berkontribusi ke sejumlah kunci yang melebihi nilai parameter max_partitions_contributed, beberapa kontribusi akan dihapus sehingga pengguna berkontribusi ke nilai parameter max_partitions_contributed yang tepat.

Demikian pula, sebagian besar agregasi memiliki parameter max_contributions_per_partition. Metrik ini juga disediakan di instance AggregateParams dan setiap agregasi dapat memiliki nilai terpisah untuk metrik tersebut. Keduanya membatasi kontribusi pengguna untuk setiap kunci.

Derau yang ditambahkan ke output diskalakan oleh parameter max_partitions_contributed dan max_contributions_per_partition, sehingga ada konsekuensi di sini: Nilai yang lebih besar yang ditetapkan ke setiap parameter berarti Anda menyimpan lebih banyak data, tetapi Anda mendapatkan hasil yang lebih berisik.

Beberapa agregasi memerlukan parameter min_value dan max_value, yang menentukan batas kontribusi setiap pengguna. Jika pengguna memberikan kontribusi nilai yang lebih rendah dari nilai yang ditetapkan ke parameter min_value, nilai tersebut akan dinaikkan menjadi nilai parameter. Demikian pula, jika pengguna memberikan kontribusi nilai yang lebih besar dari nilai parameter max_value, nilai tersebut akan dikurangi menjadi nilai parameter. Untuk mempertahankan lebih banyak nilai asli, Anda harus menentukan batas yang lebih besar. Derau diskalakan menurut ukuran batas, sehingga batas yang lebih besar memungkinkan Anda menyimpan lebih banyak data, tetapi Anda akan mendapatkan hasil yang lebih berisik.

Terakhir, parameter noise_kind mendukung dua mekanisme derau yang berbeda di PipelineDP: derau GAUSSIAN dan LAPLACE. Distribusi LAPLACE memberikan utilitas yang lebih baik dengan batas kontribusi yang rendah, itulah sebabnya PipelineDP menggunakannya secara default. Namun, jika ingin menggunakan derau distribusi GAUSSIAN, Anda dapat menentukannya di instance AggregateParams.

9. Selamat

Bagus! Anda telah menyelesaikan codelab PipelineDP dan mempelajari banyak hal tentang privasi diferensial dan PipelineDP.

Pelajari lebih lanjut