PipelineDP ile özel istatistikleri hesaplama

1. Başlamadan önce

Toplu istatistiklerin, ait oldukları kişiler hakkında herhangi bir bilgi sızdırmadığını düşünebilirsiniz. Bununla birlikte, bir saldırganın kişiler hakkındaki hassas bilgileri toplu istatistiklerden öğrenmesinin birçok yolu vardır.

Bu codelab'de, bireylerin korunması için PipelineDP'den diferansiyel özel toplamalar kullanarak nasıl özel istatistikler oluşturabileceğinizi öğreneceksiniz. gizlilik. PipelineDP, Apache Spark ve Apache Beam gibi toplu işleme sistemleriyle büyük veri kümelerine diferansiyel gizlilik uygulamanıza olanak tanıyan bir Python çerçevesidir. Go'da diferansiyel gizli istatistiklerin nasıl hesaplanacağı hakkında daha fazla bilgi edinmek için Işınlama'da Gizlilik codelab'ine bakın.

Özel, çıktının, verilerdeki kişilerle ilgili hiçbir özel bilgiyi sızdırmayacak şekilde üretilmesi anlamına gelir. Bu sonucu, güçlü bir gizlilik kavramı olan anonimleştirme (kullanıcı gizliliğini korumak için birden çok kullanıcıdan veri toplama işlemi) olan diferansiyel gizlilik ile elde edebilirsiniz. Tüm anonimleştirme yöntemleri toplama kullanır, ancak tüm toplama yöntemleri anonimleştirme sağlamaz. Diğer yandan diferansiyel gizlilik, bilgi sızıntısı ve gizlilik hakkında ölçülebilir garantiler sağlar.

Ön koşullar

• Python'a aşinalık
• Temel veri toplama hakkında bilgi
• Pandalar, Spark ve Beam deneyimi

Neler öğreneceksiniz?

• Diferansiyel gizlilikle ilgili temel bilgiler
• PipelineDP ile diferansiyel özel özet istatistikleri hesaplama
• Ek gizlilik ve yardımcı program parametreleriyle sonuçlarınızı nasıl düzenleyebilirsiniz?

Gerekenler

• Codelab'i kendi ortamınızda çalıştırmak istiyorsanız bilgisayarınızda Python 3.7 veya sonraki bir sürümün yüklü olması gerekir.
• Codelab'i kendi ortamınız olmadan izlemek istiyorsanız Colaboratory erişimine sahip olmanız gerekir.

2. Diferansiyel gizliliği anlama

Diferansiyel gizliliği daha iyi anlamak için bu basit örneğe bakın.

Bir online moda perakendecisinin pazarlama bölümünde çalıştığınızı ve satılma olasılığı en yüksek ürünlerinizin hangileri olduğunu öğrenmek istediğinizi hayal edin.

Bu grafik, müşterilerin mağazanın web sitesini ziyaret ettiklerinde ilk olarak hangi ürünlere baktığını gösterir: tişört, kazak, çorap, kot pantolon. Tişörtler en popüler ürünler arasında yer alırken çoraplar en az tercih edilen ürünlerdir.

Yararlı görünüyor, ancak bir sürpriz var. Müşterilerin bir satın alma işlemi yapıp yapmadıkları veya hangi ürünü daha sonra görüntüledikleri gibi ek bilgileri dikkate almak istediğinizde, verilerinizde belirli kişileri gösterme riskiyle karşı karşıya kalırsınız.

Bu grafikte, yalnızca bir müşterinin önce bir kazağa bakıp daha sonra satın alma işlemi gerçekleştirdiği gösterilmektedir:

Bu, gizlilik açısından pek iyi bir fikir değil. Anonimleştirilmiş istatistikler bireysel katkıları ifşa etmemelidir; o halde ne yaparsınız? Çubuk grafiklerinize rastgele parazit ekleyerek grafiklerinizin doğruluk düzeyini düşürebilirsiniz.

Bu çubuk grafik tamamen doğru olmasa da yararlıdır ve bireysel katkıları açıklamaz:

Diferansiyel gizlilik, bireysel katkıları maskelemek için doğru miktarda rastgele gürültünün eklenmesidir.

Bu örnek aşırı basitleştirilmiştir. Diferansiyel gizliliğin doğru şekilde uygulanması daha karmaşıktır ve uygulamadaki beklenmedik bazı incelikleri de beraberinde getirir. Kriptografiye benzer şekilde, kendi diferansiyel gizlilik uygulamanızı oluşturmak çok iyi bir fikir olmayabilir. Bunun yerine PipelineDP'yi kullanabilirsiniz.

3. PipelineDP'yi indirin ve yükleyin

İlgili tüm kod ve grafikleri bu dokümanda bulabileceğiniz için bu codelab'de PipelineDP'yi yüklemeniz gerekmez.

PipelineDP ile oynamak için uygulamayı kendiniz çalıştırabilir veya daha sonra kullanabilirsiniz:

• PipelineDP'yi indirip yükleyin:

pip install pipeline-dp

Örneği Apache Beam kullanarak çalıştırmak istiyorsanız:

• Apache Beam'i indirin ve yükleyin:

pip install apache_beam

Bu codelab'in kodunu ve veri kümesini PipelineDP/examples/codelab/ dizininde bulabilirsiniz.

4. Görüntülenen ilk ürün başına dönüşüm metriklerini hesapla

İnternet üzerinden satış yapan bir moda perakendecisinde çalıştığınızı ve farklı ürün kategorilerinizden hangilerinin ilk görüntülendiğinde en yüksek dönüşüm sayısını ve değerini oluşturduğunu anlamak istediğinizi varsayalım. Bu bilgileri pazarlama ajansınızla ve şirket içindeki diğer ekiplerle paylaşmak istiyorsunuz ancak herhangi bir müşteri hakkındaki bilgilerin sızdırılmasını önlemek istiyorsunuz.

Web sitesi için görüntülenen ilk ürün başına dönüşüm metriklerini hesaplamak için:

1. PipelineDP/examples/codelab/ dizininde web sitenize yapılan ziyaretlerin örnek veri kümesini inceleyin.

Bu ekran görüntüsü, veri kümesinin bir örneğidir. Kullanıcının kimliğini, görüntülediği ürünleri, ziyaretçinin dönüşüm gerçekleştirip gerçekleştirmediğini ve dönüşüm gerçekleştirdiyse, dönüşümün değerini içerir.

user_id	product_view_0	product_view_1	product_view_2	product_view_3	product_view_4	has_conversion	conversion_value
0	kot pantolon	t_shirt	t_shirt	yok	yok	false	0,0
1	kot pantolon	t_shirt	kot pantolon	kazak	yok	false	0,0
2	t_shirt	kazak	t_shirt	t_shirt	yok	true	105,19
3	t_shirt	t_shirt	kot pantolon	yok	yok	false	0,0
4	t_shirt	çorap	kot pantolon	kot pantolon	yok	false	0,0

Şu metriklerle ilgileniyorsunuz:

• view_counts: Web sitenizin ziyaretçilerinin her bir ürünü ilk olarak görme sayısı.
• total_conversion_value: Ziyaretçilerin dönüşüm gerçekleştirdiğinde harcadığı toplam para tutarı.
• conversion_rate: Ziyaretçilerin dönüşüm gerçekleştirme oranı.

2. Metrikleri gizli olmayan bir şekilde oluşturun:

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)

Daha önce de öğrendiğiniz gibi, bu istatistikler veri kümenizdeki bireyler hakkında bilgi verebilir. Örneğin, bir kişi ilk atlayışı gördüğünde yalnızca bir kişi dönüşüm gerçekleştirmiştir. 22 görüntüleme için dönüşüm oranınız yaklaşık 0, 05'tir. Şimdi her bir çubuk grafiği gizli bir çubuk haline dönüştürmeniz gerekiyor.

3. Gizlilik parametrelerinizi pipeline_dp.NaiveBudgetAccountant sınıfıyla tanımlayın ve ardından analiziniz için kullanmak istediğiniz epsilon ve delta bağımsız değişkenlerini belirtin.

Bu bağımsız değişkenleri nasıl ayarlayacağınız belirlediğiniz soruna bağlıdır. Bunlar hakkında daha fazla bilgi edinmek için İsteğe bağlı: Diferansiyel gizlilik parametrelerini ayarlama bölümüne bakın.

Bu kod snippet'i örnek değerler kullanır:

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

4. LocalBackend örneğini başlatın:

ops = pipeline_dp.LocalBackend()

Bu programı Beam veya Spark gibi ek çerçeveler olmadan yerel olarak çalıştırdığınız için LocalBackend örneğini kullanabilirsiniz.

5. DPEngine örneğini başlatın:

dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

PipelineDP, pipeline_dp.AggregateParams sınıfı aracılığıyla daha fazla parametre belirtmenize olanak tanır. Bu, özel istatistiklerinizin oluşturulmasını etkiler.

params = pipeline_dp.AggregateParams(
     noise_kind=pipeline_dp.NoiseKind.LAPLACE,
     metrics=[pipeline_dp.Metrics.COUNT],
     max_partitions_contributed=1,
     max_contributions_per_partition=1)

6. count metriğini hesaplamak istediğinizi belirtin ve LAPLACE gürültü dağılımını kullanın.
7. max_partitions_contributed bağımsız değişkenini 1 değerine ayarlayın.

Bu bağımsız değişken, bir kullanıcının katkıda bulunabileceği farklı ziyaret sayısını sınırlar. Kullanıcıların web sitesini günde bir kez ziyaret etmesini bekliyorsunuz ve gün içinde siteyi birden fazla kez ziyaret edip etmedikleri sizin için önemli değil.

8. max_contributions_per_partitions bağımsız değişkenini 1 değerine ayarlayın.

Bu bağımsız değişken, tek bir ziyaretçinin bu durumda tek bir bölüme veya ürün kategorisine kaç katkıda bulunabileceğini belirtir.

9. privacy_id, partition ve value alanlarının nerede bulunacağını belirten bir data_extractor örneği oluşturun.

Kodunuz şu kod snippet'i gibi görünmelidir:

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. Pandas DataFrame'inizi, diferansiyel gizli istatistikleri doğrudan hesaplayabileceğiniz bir satır listesine dönüştürmek için aşağıdaki kodu ekleyin:

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

Tebrikler! Diferansiyel gizliliğe sahip ilk istatistiğinizi hesapladınız.

Bu grafikte, daha önce hesapladığınız gizli olmayan sayının yanında diferansiyel gizli sayınızın sonucu gösterilir:

Kodu çalıştırdığınızda gördüğünüz çubuk grafik bundan farklı olabilir. Bu normaldir. Diferansiyel gizlilikteki gürültü nedeniyle, kodu her çalıştırdığınızda farklı bir çubuk grafik görüntülenir ancak bunların, gizli olmayan orijinal çubuk grafiğe benzer olduğunu görebilirsiniz.

Gizlilik garantileri kapsamında, ardışık düzeni birden fazla kez çalıştırmamanın gizlilik garantileri açısından çok önemli olduğunu lütfen unutmayın. Daha fazla bilgi için Birden çok istatistik hesaplama bölümüne bakın.

5. Herkese açık bölümleri kullan

Önceki bölümde, bir bölüm (yani web sitenizde çorapları ilk kez gören ziyaretçiler) için tüm ziyaret verilerini bıraktığınızı fark etmiş olabilirsiniz.

Bunun nedeni bölüm seçimi veya eşiktir. Çıkış bölümlerinin varlığı kullanıcı verilerine bağlı olduğunda diferansiyel gizlilik garantilerini sağlamak için önemli bir adımdır. Böyle bir durumda, çıkışta sadece bir bölümün mevcut olması, verilerdeki bireysel bir kullanıcının varlığını sızdırabilir. Bunun gizliliği neden ihlal ettiğiyle ilgili daha fazla bilgi edinmek için bu blog yayınına bakın. Bu gizlilik ihlalini önlemek için PipelineDP, yalnızca yeterli sayıda kullanıcı içeren bölümleri tutar.

Çıkış bölümleri listesi gizli kullanıcı verilerine bağlı olmadığında, bu bölüm seçimi adımına ihtiyacınız yoktur. Bir müşterinin ilk olarak görebileceği tüm olası ürün kategorilerini bildiğinizden bu durum sizin örneğiniz için de geçerlidir.

Bölümlendirmeleri kullanmak için:

1. Olası bölümlerinizin listesini oluşturun:

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

2. Listeyi, pipeline_dp.AggregateParams sınıfına ek bir giriş olarak ayarlayan run_pipeline() işlevine iletin:

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)

Herkese açık bölümler ve LAPLACE gürültüsü kullanıyorsanız total_delta bağımsız değişkenini 0 değerine ayarlayabilirsiniz.

Artık sonuçta tüm bölümlere veya ürünlere ilişkin verilerin raporlandığını görüyorsunuz.

Herkese açık bölümler, daha fazla bölümü tutmanıza olanak tanır. Ayrıca bölüm seçimi için herhangi bir gizlilik bütçesi harcamadığınız için yarı yarıya daha fazla gürültü ekler. Bu nedenle, ham ve gizli sayılar arasındaki fark önceki çalıştırmaya göre biraz daha azdır.

Herkese açık bölümleri kullanırken göz önünde bulundurmanız gereken iki önemli nokta vardır:

• Ham verilerden bölüm listesini türetirken dikkatli olun. Bunu diferansiyel gizlilikle yapmazsanız ardışık düzeniniz artık diferansiyel gizlilik garantileri sağlamaz. Daha fazla bilgi için Gelişmiş: Verilerden bölüm türetme bölümüne bakın.
• Herkese açık bölümlerin bazıları için veri yoksa diferansiyel gizliliği korumak için bu bölümlere gürültü uygulamanız gerekir. Örneğin, veri kümenizde veya web sitenizde bulunmayan ek bir ürün (ör. pantolon) kullandıysanız bu ürün yine de gürültüdür ve sonuçlarda, ürün ziyaretleri yokken bazı ürün ziyaretleri gösterilebilir.

Gelişmiş: Verilerden bölüm türetme

Aynı ardışık düzende herkese açık olmayan çıkış bölümleriyle aynı listeyle birden fazla toplama çalıştırırsanız dp_engine.select_private_partitions() yöntemiyle bölüm listesini bir kez türetebilir ve her toplama işlemine bölümleri, public_partitions girişi olarak sağlayabilirsiniz. Bu yöntem hem gizlilik açısından güvenli hem de daha az gürültü eklemenize olanak tanır. Çünkü gizlilik bütçesini tüm ardışık düzen için bölüm seçiminde yalnızca bir kez kullandığınızdan emin olun.

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. Çoklu istatistik işlemleri

Artık PipelineDP'nin nasıl çalıştığını bildiğinize göre daha gelişmiş bazı kullanım alanları için nasıl kullanabileceğinizi görebilirsiniz. Başta da belirtildiği gibi, üç istatistikle ilgileniyorsunuz. PipelineDP, daha sonra göreceğiniz AggregateParams örneğinde aynı parametreleri paylaştıkları sürece birden fazla istatistiği aynı anda hesaplamanıza olanak tanır. Birden fazla metriğin tek seferde hesaplanması daha anlaşılır ve kolay olmasının yanı sıra gizlilik açısından da daha iyidir.

NaiveBudgetAccountant sınıfına sağladığınız epsilon ve delta parametrelerini hatırlarsanız bunlar gizlilik bütçesi adı verilen bir şeyi temsil eder. Bu parametreler, verilerden sızdırdığınız kullanıcı gizliliği miktarının bir ölçümüdür.

Gizlilik bütçesinin unutulmaması gereken önemli bir nokta, bütçenin katkı sağlamasıdır. Tek seferde belirli bir epsilon £ ve delta gün değeri taşıyan bir ardışık düzen çalıştırırsanız bir (▼,5) bütçe harcarsınız. Kampanyayı ikinci kez çalıştırırsanız toplamda (2£, 2Δ) tutarında bütçe harcarsınız. Benzer şekilde, NaiveBudgetAccountant yöntemi ile birden fazla istatistik hesaplar ve art arda £,VAT tutarında bir gizlilik bütçesi kullanırsanız toplam (2£, 2Δ) tutarında bir bütçe harcarsınız. Bu durumda gizlilik garantilerini azaltmış olursunuz.

Bunu atlatmak için, aynı veriler üzerinden birden fazla istatistiği hesaplamanız gerektiğinde kullanmak istediğiniz toplam bütçeye sahip tek bir NaiveBudgetAccountant örneği kullanmanız gerekir. Ardından her toplama için kullanmak istediğiniz epsilon ve delta değerlerini belirtmeniz gerekir. Sonuçta aynı genel gizlilik garantisine sahip olursunuz ancak belirli bir toplamanın epsilon ve delta değerleri ne kadar yüksek olursa doğruluğu da o kadar yüksek olur.

Bunu uygulamalı olarak görmek için count, mean ve sum istatistiklerini hesaplayabilirsiniz.

İstatistikleri iki farklı metriğe göre hesaplarsınız: İlk olarak hangi ürünün görüntülendiğini temel alarak elde edilen gelir tutarını tahmin etmek için kullanacağınız bir conversion_value metriği ve web sitenize gelen ziyaretçi sayısını ve ortalama dönüşüm oranını hesaplamak için kullandığınız has_conversion metriği.

Her bir metrik için, özel istatistiklerin hesaplanmasına yol açan parametreleri ayrı olarak belirtmeniz gerekir. Gizlilik bütçenizi iki metriğe bölersiniz. has_conversion metriğinden iki istatistik hesaplıyorsunuz, bu nedenle bu metriğe başlangıç bütçenizin üçte ikisini ve diğer üçte birini conversion_value metriğine atamak istiyorsunuz.

Birden çok istatistiği hesaplamak için:

1. Üç istatistikte kullanmak istediğiniz toplam epsilon ve delta değerleriyle gizlilik bütçesi muhasebecinizi ayarlayın:

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

2. Metriklerinizi hesaplamak için DPEngine uygulamasını başlatın:

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

3. Bu metriğe ilişkin parametreleri belirtin.

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)

Son bağımsız değişken isteğe bağlı olarak gizlilik bütçenizin ağırlığını belirtir. Tümüne aynı ağırlığı verebilirsiniz, ancak bu bağımsız değişkeni daha önce açıklandığı gibi üçte birine ayarlamak istersiniz.

Bölümdeki bir gizlilik biriminin katkıda bulunduğu değere uygulanan alt ve üst sınırı belirtmek için min_value ve max_value bağımsız değişkeni de ayarladınız. Özel bir toplam veya ortalama hesaplamak istediğinizde bu parametreler gereklidir. Negatif değer beklemediğiniz için 0 ve 100 değerlerinin makul sınırlar olduğunu varsayabilirsiniz.

4. İlgili verileri çıkarın ve ardından toplama işlevine iletin:

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. İki metriği has_conversion değişkeninize göre hesaplamak için aynı adımları uygulayın:

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

Tek değişiklik, artık mean ve count metriklerini toplam olarak tanımladığınız ve bu hesaplamaya gizlilik bütçenizin üçte ikisini atadığınız pipeline_dp.AggregateParams durumunda gerçekleşecek. Her iki istatistik için de aynı katkı sınırlarını aynı has_conversion değişkeni üzerinde hesaplamak istediğinizde, bu sınırları aynı pipeline_dp.AggregateParams örneğinde birleştirip aynı anda hesaplayabilirsiniz.

6. budget_accountant.compute_budgets() yöntemini çağırın:

budget_accountant.compute_budgets()

Üç özel istatistiğin orijinal istatistikleriyle karşılaştırma yapabilirsiniz. Eklenen gürültüye bağlı olarak sonuçların aslında makul ölçeğin dışında kalabileceğini görürsünüz. Bu durumda, eklenen gürültü sıfır civarında simetrik olduğundan, atlamacılar için negatif bir dönüşüm oranı ve toplam dönüşüm değeri görürsünüz. Daha ayrıntılı analiz ve işleme için özel istatistikleri manuel olarak sonradan işleme almak en iyisidir. Ancak bu grafikleri bir rapora eklemek istediğinizde gizlilik garantilerini ihlal etmeden minimum değeri sıfır olarak ayarlamanız yeterlidir.

7. Ardışık düzeni Beam ile çalıştırma

Günümüzde veri işleme, büyük miktarlarda veriyle uğraşmanızı gerektirdiğinden bu verileri yerel olarak işleyememeniz gerekir. Bunun yerine birçok kişi, Beam veya Spark gibi büyük ölçekli veri işleme çerçeveleri kullanır ve ardışık düzenlerini bulutta çalıştırır.

PipelineDP, kodunuzda yalnızca küçük değişiklikler yaparak Beam ve Spark'ı destekler.

Ardışık düzeni private_beam API ile Beam ile çalıştırmak için:

1. Bir runner değişkenini başlatın ve ardından gizlilik işlemlerinizi rows öğenizin Beam temsiline uygulayacağınız bir ardışık düzen oluşturun:

runner = fn_api_runner.FnApiRunner()  # local runner

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

2. Zorunlu gizlilik parametrelerinizle bir budget_accountant değişkeni oluşturun:

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

3. Tüm toplamaların gizlilik gereksinimlerinize uygun olmasını garanti eden bir pcol veya özel koleksiyon değişkeni oluşturun:

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

4. Özel toplamanızın parametrelerini uygun sınıfta belirtin.

Burada, ürün görüntülemelerinin toplamını hesapladığınız için pipeline_dp.aggregate_params.SumParams()sınıfını kullanıyorsunuz.

5. İstatistiğinizi hesaplamak için toplama parametrelerinizi pbeam.Sum yöntemine iletin:

dp_result = pcol | pbeam.Sum(params)

6. Sonuç olarak, kodunuz şu kod snippet'i gibi görünmelidir:

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. İsteğe bağlı: Gizlilik ve yardımcı program parametrelerini ayarlama

Bu codelab'de epsilon, delta ve max_partitions_contributed gibi birçok parametreden bahsedildi. Bunları genel olarak iki kategoriye ayırabilirsiniz: gizlilik parametreleri ve yardımcı program parametreleri.

Gizlilik parametreleri

epsilon ve delta parametreleri, diferansiyel gizlilikle sağladığınız gizliliği ölçer. Daha net ifade etmek gerekirse, potansiyel bir saldırganın anonimleştirilmiş çıktıdan elde edilen veriler hakkında ne kadar bilgi edinebileceğinin bir ölçüsüdür. Parametrelerin değeri ne kadar yüksek olursa saldırganın veriler hakkında o kadar fazla bilgi edinir ve bu da gizlilik riski oluşturur. Öte yandan, epsilon ve delta parametrelerinin değeri ne kadar düşük olursa çıkışı anonim hale getirmek için o kadar fazla gürültü eklemeniz gerekir ve bunları anonimleştirilmiş çıktıda tutmak için her bölümde ihtiyacınız olan benzersiz kullanıcı sayısı o kadar yüksek olur. Bu durumda, fayda ile gizlilik arasında bir denge vardır.

PipelineDP'de, NaiveBudgetAccountant örneğinde toplam gizlilik bütçesini ayarladığınızda anonimleştirilmiş çıkışınızla ilgili istediğiniz gizlilik garantilerini belirtmeniz gerekir. Gizlilik garantilerinizin geçerli olmasını istiyorsanız bütçenizin aşırı kullanılmasını önlemek amacıyla her toplama için dikkatli bir şekilde ayrı bir NaiveBudgetAccountant örneği kullanmanız veya ardışık düzeni birden fazla kez çalıştırmanız gerektiğini unutmayın.

Diferansiyel gizlilik ve gizlilik parametrelerinin ne anlama geldiği hakkında daha fazla bilgi edinmek için Diferansiyel gizlilikle ilgili bir okuma listesi bölümüne bakın.

Yardımcı program parametreleri

Yardımcı program parametreleri gizlilik garantilerini etkilemez ancak doğruluğu ve dolayısıyla da sonucun faydasını etkiler. Bunlar AggregateParams örneğinde sağlanır ve eklenen gürültüyü ölçeklendirmek için kullanılır.

AggregateParams örneğinde sağlanan ve tüm toplamalarda geçerli olan bir yardımcı program parametresi max_partitions_contributed parametresidir. Bölümlendirme, PipelineDP toplama işlemi tarafından döndürülen verilerin anahtarına karşılık gelir. Bu nedenle, max_partitions_contributed parametresi, kullanıcının çıkışa katkıda bulunabileceği farklı anahtar değerlerinin sayısını sınırlar. Bir kullanıcı, max_partitions_contributed parametresinin değerini aşan bir sayıda anahtara katkıda bulunursa bazı katkılar, max_partitions_contributed parametresinin tam değerine katkıda bulunmaları için atlanır.

Benzer şekilde çoğu toplamada max_contributions_per_partition parametresi bulunur. Bunlar AggregateParams örneğinde de sağlanır ve her toplama bunların için ayrı değerlere sahip olabilir. Her anahtar için bir kullanıcının katkısını bağladılar.

Çıkışa eklenen gürültü, max_partitions_contributed ve max_contributions_per_partition parametrelerine göre ölçeklendirilir. Bu nedenle, burada bir denge söz konusudur. Her parametreye daha büyük değerler atanması, daha fazla veri saklayacağınız ancak daha gürültülü bir sonuç alacağınız anlamına gelir.

Bazı toplama işlemleri için her kullanıcının katkı sınırlarını belirten min_value ve max_value parametresi gerekir. Bir kullanıcı, min_value parametresine atanan değerden daha düşük bir değere katkıda bulunursa değer, parametrenin değerine yükseltilir. Benzer şekilde, bir kullanıcı max_value parametresinin değerinden daha büyük bir değere katkıda bulunursa değer, parametrenin değerine düşürülür. Orijinal değerlerin daha fazlasını tutmak için daha büyük sınırlar belirtmeniz gerekir. Gürültü, sınırların boyutlarına göre ölçeklendirildiğinden, daha büyük sınırlar daha fazla veri saklamanıza olanak tanır ancak sonuçta daha gürültülü bir sonuç elde edersiniz.

Son olarak, noise_kind parametresi PipelineDP'de iki farklı gürültü mekanizmasını destekler: GAUSSIAN ve LAPLACE gürültü. LAPLACE dağılımı, düşük katkı sınırlarıyla daha iyi fayda sağlar. Bu nedenle, PipelineDP bunu varsayılan olarak kullanır. Ancak GAUSSIAN dağıtım gürültüsü kullanmak isterseniz bunu AggregateParams örneğinde belirtebilirsiniz.

9. Tebrikler

Tebrikler! PipelineDP codelab'ini tamamlayarak diferansiyel gizlilik ve PipelineDP hakkında birçok şey öğrendiniz.

Daha fazla bilgi

• GitHub deposu
• PipelineDP
• Işınlama'da gizlilik codelab'i