Menghitung statistik pribadi dengan PipelineDP

1. Sebelum memulai

Anda mungkin berpikir bahwa statistik gabungan tidak membocorkan informasi apa pun tentang individu yang terkait. Namun, ada banyak cara bagi penyerang untuk mempelajari informasi sensitif tentang individu dari statistik gabungan.

Dalam codelab ini, Anda akan mempelajari cara membuat statistik pribadi dengan agregasi pribadi yang berbeda dari PipelineDP untuk melindungi privasi individu privasi. 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 pribadi yang berbeda di Go, lihat codelab Privacy on Beam.

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

Prasyarat

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

Yang akan Anda pelajari

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

Yang Anda butuhkan

• Jika ingin menjalankan codelab di lingkungan sendiri, Anda harus menginstal Python 3.7 atau versi yang lebih baru di komputer.
• 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 sebuah retailer mode online dan ingin memahami produk mana yang kemungkinan besar akan terjual.

Diagram ini menunjukkan produk yang dilihat pelanggan pertama kali saat mengunjungi situs toko: kaus, jumper, kaus kaki, atau jeans. Kaus adalah produk yang paling populer sementara kaus kaki adalah barang yang paling tidak populer.

Ini tampak 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 individu dalam data Anda.

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

Ini tidak bagus dari sudut pandang privasi. Statistik yang dianonimisasi seharusnya tidak mengungkapkan kontribusi individu, jadi apa yang harus Anda lakukan? Anda menambahkan derau acak ke diagram batang agar sedikit kurang akurat.

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

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

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

3. Mendownload dan menginstal PipelineDP

Anda tidak perlu menginstal PipelineDP, ikuti 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. Hitung metrik konversi per produk pertama yang dilihat

Bayangkan Anda bekerja di retailer mode online dan ingin memahami mana dari berbagai kategori produk yang menghasilkan jumlah dan nilai konversi tertinggi saat dilihat pertama kali. Anda ingin membagikan informasi ini dengan agensi pemasaran dan 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. Laporan ini berisi ID pengguna, produk yang dilihat pengguna, apakah pengunjung melakukan konversi, dan, jika ya, nilai konversi.

user_id	product_view_0	product_view_1	product_view_2	product_view_3	product_view_4	has_conversion	conversion_value
0	celana jeans	t_shirt	t_shirt	tidak ada	tidak ada	salah	0,0
1	celana jeans	t_shirt	celana jeans	lompat tali	tidak ada	salah	0,0
2	t_shirt	jumper	t_shirt	t_shirt	tidak ada	true	105,19
3	t_shirt	t_shirt	celana jeans	tidak ada	tidak ada	salah	0,0
4	t_shirt	kaus kaki	celana jeans	celana jeans	tidak ada	salah	0,0

Anda tertarik dengan metrik ini:

• view_counts: Berapa kali pengunjung situs melihat setiap produk terlebih dahulu.
• total_conversion_value: Total jumlah uang yang dibelanjakan pengunjung saat mereka melakukan konversi.
• conversion_rate: Rasio saat pengunjung melakukan konversi.

2. Buat metrik dengan cara yang tidak bersifat 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 {i>dataset<i} Anda. Misalnya, hanya satu orang yang melakukan konversi setelah orang tersebut melihat jumper terlebih dahulu. Untuk 22 penayangan, rasio konversi Anda adalah sekitar 0,05. Sekarang Anda perlu mengubah setiap diagram batang menjadi diagram pribadi.

3. Tentukan parameter privasi dengan class pipeline_dp.NaiveBudgetAccountant, lalu tentukan argumen epsilon dan delta yang ingin digunakan untuk analisis.

Cara menetapkan argumen ini bergantung pada masalah tertentu yang Anda hadapi. Untuk mempelajarinya lebih lanjut, lihat Opsional: Menyesuaikan parameter privasi diferensial.

Cuplikan kode ini menggunakan nilai contoh:

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

4. Lakukan inisialisasi instance LocalBackend:

ops = pipeline_dp.LocalBackend()

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

5. 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.

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. Tentukan bahwa Anda ingin menghitung metrik count dan menggunakan distribusi derau LAPLACE.
7. Tetapkan argumen max_partitions_contributed ke nilai 1.

Argumen ini membatasi jumlah kunjungan berbeda yang dapat dikontribusikan oleh pengguna. Anda mengharapkan pengguna mengunjungi situs web sekali sehari dan Anda tidak peduli apakah mereka mengunjunginya beberapa kali dalam sehari.

8. Tetapkan argumen max_contributions_per_partitions ke nilai 1.

Argumen ini menentukan berapa banyak kontribusi yang dapat diberikan oleh seorang pengunjung pada partisi individual atau kategori produk dalam kasus ini.

9. Buat instance data_extractor yang menentukan tempat 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

10. Tambahkan kode ini untuk mengubah DataFrame Pandas menjadi daftar baris tempat Anda dapat langsung menghitung statistik pribadi diferensial:

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 pribadi diferensial pertama Anda!

Diagram ini menunjukkan hasil jumlah pribadi diferensial di samping jumlah non pribadi yang Anda hitung sebelumnya:

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

Harap diperhatikan bahwa sangat penting untuk menjamin privasi agar 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 telah mengetahui bahwa Anda telah menghapus semua data kunjungan untuk sebuah partisi, yaitu pengunjung yang pertama kali melihat kaus kaki di situs Anda.

Hal ini karena pemilihan atau nilai minimum partisi, yang merupakan langkah penting untuk memastikan jaminan privasi diferensial saat keberadaan partisi output bergantung pada data pengguna itu sendiri. Ketika ini terjadi, keberadaan partisi di {i>output<i} dapat membocorkan keberadaan pengguna individu dalam data. Untuk mempelajari lebih lanjut alasan pelanggaran privasi, lihat postingan blog ini. Untuk mencegah pelanggaran privasi ini, PipelineDP hanya menyimpan partisi dengan jumlah pengguna yang memadai.

Jika daftar partisi output tidak bergantung pada data pengguna pribadi, Anda tidak memerlukan langkah pemilihan partisi ini. Hal ini sebenarnya berlaku untuk contoh Anda karena Anda mengetahui semua kategori produk yang mungkin dapat dilihat pertama kali oleh pelanggan.

Untuk menggunakan partisi:

1. Buat daftar partisi yang memungkinkan:

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

2. 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 menggunakan partisi publik dan derau LAPLACE, Anda dapat menetapkan argumen total_delta ke nilai 0.

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

Partisi publik tidak hanya memungkinkan Anda menyimpan lebih banyak partisi, tetapi juga menambahkan sekitar setengah jumlah derau karena Anda tidak mengeluarkan anggaran privasi untuk pemilihan partisi, sehingga perbedaan antara jumlah mentah dan pribadi sedikit lebih kecil dibandingkan dengan proses sebelumnya.

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

• Berhati-hatilah saat Anda mendapatkan daftar partisi dari data mentah. Jika Anda tidak melakukan ini dengan cara privasi diferensial, pipeline Anda tidak lagi memberikan jaminan privasi diferensial. Untuk mengetahui informasi selengkapnya, lihat Lanjutan: Memperoleh 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 muncul di set data atau di situs Anda, produk tersebut masih berisi derau dan hasilnya mungkin menampilkan beberapa kunjungan ke produk padahal tidak ada.

Lanjutan: Memperoleh partisi dari data

Jika menjalankan beberapa agregasi dengan daftar partisi output non-publik yang sama dalam pipeline yang sama, Anda dapat memperoleh daftar partisi sekali dengan metode dp_engine.select_private_partitions() dan memberikan partisi ke setiap agregasi sebagai input public_partitions. Selain aman dari perspektif privasi, cara ini juga memungkinkan Anda menambahkan lebih sedikit derau karena Anda hanya menggunakan anggaran 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 banyak statistik

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

Jika Anda ingat parameter epsilon dan delta yang Anda berikan ke class NaiveBudgetAccountant, parameter tersebut mewakili sesuatu yang disebut anggaran privasi, yang merupakan ukuran jumlah privasi pengguna yang Anda bocor dari data.

Hal penting yang perlu diingat tentang anggaran privasi adalah anggaran tersebut bersifat tambahan. Jika Anda menjalankan pipeline dengan epsilon ε dan delta lak tertentu satu kali, Anda membelanjakan anggaran ( resource), Anda menghabiskan anggaran ( Gunakan, Wilayah). Jika menjalankannya untuk kedua kalinya, Anda membelanjakan total anggaran sebesar (2return, 2 keluar). Demikian pula, jika Anda menghitung beberapa statistik dengan metode NaiveBudgetAccountant dan secara berturut-turut dengan anggaran privasi sebesar ε,keluar, Anda membelanjakan total anggaran sebesar (22, 2Ubah). Ini berarti Anda menurunkan jaminan privasi.

Untuk mengakalinya, Anda harus menggunakan satu instance NaiveBudgetAccountant dengan total anggaran yang ingin digunakan saat Anda perlu menghitung beberapa statistik pada data yang sama. Selanjutnya, Anda harus 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 melihat cara kerjanya, Anda dapat menghitung statistik count, mean, dan sum.

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

Untuk setiap metrik, Anda perlu menentukan parameter yang memandu penghitungan statistik pribadi secara terpisah. Anda membagi anggaran privasi ke kedua metrik. Anda menghitung dua statistik dari metrik has_conversion, jadi Anda ingin menetapkan dua pertiga dari anggaran awal Anda dan menetapkan sepertiga lainnya ke 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)

2. Lakukan inisialisasi DPEngine untuk menghitung metrik Anda:

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

3. 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 kepada semua orang, tetapi Anda ingin menetapkan 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 ke nilai yang dikontribusikan oleh unit privasi dalam partisi. Parameter ini diperlukan saat Anda ingin menghitung jumlah atau rata-rata pribadi. Anda tidak mengharapkan nilai negatif, sehingga Anda dapat menganggap 0 dan 100 sebagai batas yang wajar.

4. 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))

5. Ikuti langkah-langkah yang sama untuk menghitung kedua metrik berdasarkan variabel has_conversion Anda:

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, tempat Anda sekarang menentukan 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.

6. Panggil metode budget_accountant.compute_budgets():

budget_accountant.compute_budgets()

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

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 dengan hanya perubahan kecil pada kode Anda.

Untuk menjalankan pipeline dengan Beam dengan private_beam API:

1. Lakukan inisialisasi variabel runner, lalu buat pipeline tempat Anda menerapkan operasi privasi ke representasi Beam dari rows:

runner = fn_api_runner.FnApiRunner()  # local runner

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

2. Buat variabel budget_accountant dengan parameter privasi yang diperlukan:

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

3. Buat pcol, atau variabel koleksi pribadi, yang menjamin bahwa setiap agregasi sesuai dengan persyaratan privasi Anda:

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

4. Tentukan parameter agregasi pribadi di class yang sesuai.

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

5. Teruskan parameter agregasi ke metode pbeam.Sum untuk menghitung statistik Anda:

dp_result = pcol | pbeam.Sum(params)

6. 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, data merupakan ukuran seberapa banyak informasi yang dapat diperoleh calon penyerang tentang data dari output anonim. Semakin tinggi nilai parameter, semakin banyak informasi yang diperoleh penyerang tentang data, yang merupakan risiko privasi. Di sisi lain, semakin rendah nilai parameter epsilon dan delta, semakin banyak derau yang perlu ditambahkan ke output untuk membuatnya anonim dan semakin tinggi jumlah pengguna unik yang Anda perlukan di setiap partisi untuk menyimpannya dalam output anonim. Dalam hal ini, ada penyeimbangan antara utilitas dan privasi.

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

Untuk 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, utilitas output. Label ini disediakan dalam instance AggregateParams dan digunakan untuk menskalakan derau yang ditambahkan.

Parameter utilitas yang disediakan dalam 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 oleh pengguna pada output. Jika pengguna berkontribusi pada sejumlah kunci yang melebihi nilai parameter max_partitions_contributed, beberapa kontribusi akan dihapus sehingga berkontribusi pada nilai parameter max_partitions_contributed yang tepat.

Demikian pula, sebagian besar agregasi memiliki parameter max_contributions_per_partition. Nilai juga disediakan dalam instance AggregateParams dan setiap agregasi dapat memiliki nilai terpisah. Mereka mengikat kontribusi pengguna untuk setiap kunci.

Derau yang ditambahkan ke output diskalakan menurut parameter max_partitions_contributed dan max_contributions_per_partition sehingga ada konsekuensinya: Nilai yang lebih besar yang ditetapkan ke setiap parameter berarti Anda menyimpan lebih banyak data, tetapi Anda akan 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 ke nilai parameter. Demikian pula, jika pengguna memberikan kontribusi nilai yang lebih besar dari nilai parameter max_value, nilai tersebut akan diturunkan ke nilai parameter. Untuk mempertahankan lebih banyak nilai asli, Anda harus menentukan batas yang lebih besar. Derau diskalakan menurut ukuran batas, jadi batas yang lebih besar memungkinkan Anda menyimpan lebih banyak data, tetapi pada akhirnya 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 rendah, itulah sebabnya PipelineDP menggunakannya secara default. Namun, jika ingin menggunakan derau distribusi GAUSSIAN, Anda dapat menentukannya dalam instance AggregateParams.

9. Selamat

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

Pelajari lebih lanjut

• Repositori GitHub
• PipelineDP
• Codelab Privacy on Beam