PipelineDP ile özel istatistikleri hesaplama

1. Başlamadan önce

Toplu istatistiklerin, ilgili kişiler hakkında herhangi bir bilgi sızdırmadığını düşünebilirsiniz. Ancak saldırganlar, toplu istatistiklerden bireylerle ilgili hassas bilgileri öğrenebilir.

Bu codelab'de, bireylerin gizliliğini korumak için PipelineDP'den alınan diferansiyel gizliliğe sahip toplamalarla özel istatistikler oluşturmayı öğreneceksiniz. PipelineDP, Apache Spark ve Apache Beam gibi toplu işlem sistemleriyle büyük veri kümelerine diferansiyel gizlilik uygulamanıza olanak tanıyan bir Python çerçevesidir. Go'da farklı gizlilikteki istatistiklerin nasıl hesaplanacağı hakkında daha fazla bilgi için Privacy on Beam codelab'ine bakın.

Gizli, çıkışın verilerdeki kişilerle ilgili herhangi bir özel bilgiyi sızdırmayacak şekilde üretildiği anlamına gelir. Bu sonucu, kullanıcı gizliliğini korumak için birden fazla kullanıcıdan gelen verilerin toplanması süreci olan anonimleştirme ile ilgili güçlü bir gizlilik kavramı olan diferansiyel gizlilik aracılığıyla elde edebilirsiniz. Tüm anonimleştirme yöntemlerinde toplama kullanılır ancak tüm toplama yöntemlerinde anonimleştirme sağlanmaz. Diğer yandan diferansiyel gizlilik, bilgi sızıntısı ve gizlilik konusunda ölçülebilir garantiler sunar.

Ön koşullar

• Python hakkında bilgi
• Temel veri toplama hakkında bilgi sahibi olma
• pandas, Spark ve Beam ile deneyim

Neler öğreneceksiniz?

• Diferansiyel gizliliğin temelleri
• PipelineDP ile farklı gizlilik içeren özet istatistikleri hesaplama
• Ek gizlilik ve yardımcı program parametreleriyle sonuçlarınızı nasıl ayarlayabilirsiniz?

İhtiyacınız olanlar

• 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 takip etmek istiyorsanız Colaboratory'ye erişmeniz gerekir.

2. Diferansiyel gizliliği anlama

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

Online bir moda perakendecisinin pazarlama departmanında çalıştığınızı ve hangi ürünlerinizin satılma olasılığının en yüksek olduğunu anlamak istediğinizi varsayalım.

Bu grafik, müşterilerin mağazanın web sitesini ziyaret ettiklerinde ilk olarak hangi ürünlere baktığını gösterir: tişörtler, kazaklar, çoraplar veya kot pantolonlar. En popüler ürün tişört, en az popüler ürün ise çoraptır.

Bu özellik yararlı gibi görünse de dikkat etmeniz gereken bir nokta var. Müşterilerin satın alma işlemi yapıp yapmadığı veya ikinci olarak hangi ürünü görüntülediği gibi ek bilgileri dikkate almak istediğinizde verilerinizdeki kişileri ifşa etme riskiyle karşılaşırsınız.

Bu grafik, yalnızca bir müşterinin önce kazaklara baktığını ve ardından satın alma işlemi gerçekleştirdiğini gösterir:

Bu durum, gizlilik açısından iyi değildir. Anonimleştirilmiş istatistikler, bireysel katkıları göstermemelidir. Bu durumda ne yaparsınız? Çubuk grafiklerinize rastgele gürültü ekleyerek doğruluğunu biraz azaltıyorsunuz.

Bu çubuk grafik tamamen doğru olmasa da yine de faydalıdır ve bireysel katkıları göstermez:

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

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

3. PipelineDP'yi indirme ve yükleme

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

PipelineDP ile oynamak, PipelineDP'yi kendiniz çalıştırmak veya daha sonra kullanmak için:

• PipelineDP'yi indirip yükleyin:

pip install pipeline-dp

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

• Apache Beam'i indirip 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üne göre dönüşüm metriklerini hesaplama

Online bir moda perakendecisinde çalıştığınızı ve farklı ürün kategorilerinizden hangisinin ilk görüntülendiğinde en yüksek sayıda ve değerde dönüşüm sağladığını anlamak istediğinizi varsayalım. Bu bilgileri pazarlama ajansınızın yanı sıra diğer dahili ekiplerle de paylaşmak istiyorsunuz ancak herhangi bir müşteriye ait bilgilerin sızmasını önlemek istiyorsunuz.

Web sitesi için görüntülenen ilk ürüne göre dönüşüm metriklerini hesaplamak üzere:

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

Bu ekran görüntüsü, veri kümesine bir örnektir. Kullanıcının kimliğini, kullanıcının görüntülediği ürünleri, ziyaretçinin dönüşüm gerçekleştirip gerçekleştirmediğini ve 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 pantolonlar	t_shirt	t_shirt	yok	yok	yanlış	0,0
1	kot pantolonlar	t_shirt	kot pantolonlar	jumper	yok	yanlış	0,0
2	t_shirt	jumper	t_shirt	t_shirt	yok	doğru	105,19
3	t_shirt	t_shirt	kot pantolonlar	yok	yok	yanlış	0,0
4	t_shirt	çorap	kot pantolonlar	kot pantolonlar	yok	yanlış	0,0

Aşağıdaki metriklerle ilgileniyorsunuz:

• view_counts: Web sitenizin ziyaretçilerinin her bir ürünü ilk kez gördüğü sayı.
• total_conversion_value: Ziyaretçilerin dönüşüm gerçekleştirdiklerinde harcadıkları toplam para miktarı.
• conversion_rate: Ziyaretçilerin dönüşüm gerçekleştirme oranı.

2. Metrikleri herkese açık ş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 öğrendiğiniz gibi, bu istatistikler veri kümenizdeki kişiler hakkında bilgi verebilir. Örneğin, kullanıcı önce kazak gördükten sonra yalnızca bir kişi dönüşüm gerçekleştirdi. 22 görüntüleme için dönüşüm oranınız yaklaşık 0, 05'tir. Şimdi her çubuk grafiği özel bir grafiğe dönüştürmeniz gerekiyor.

3. pipeline_dp.NaiveBudgetAccountant sınıfıyla gizlilik parametrelerinizi tanımlayın, ardından analizinizde 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, özel sorununuzla ilgilidir. Bu parametreler hakkında daha fazla bilgi edinmek için İsteğe bağlı: Diferansiyel gizlilik parametrelerinde ince ayar yapma başlıklı makaleyi inceleyin.

Bu kod snippet'inde örnek değerler kullanılmaktadı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ı yerel olarak Beam veya Spark gibi ek çerçeveler olmadan ç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 özel istatistiklerinizin oluşturulmasını etkileyen başka parametreler belirtmenize olanak tanır.

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 ve LAPLACE gürültü dağılımını kullanmak istediğinizi belirtin.
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 kaç farklı ziyaret katkısında bulunabileceğini sınırlar. Kullanıcıların web sitesini günde bir kez ziyaret etmesini bekliyorsunuz ve gün içinde birden fazla kez ziyaret etmeleri 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 aşağıdaki kod snippet'ine benzemelidir:

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, doğrudan farklı gizlilik istatistikleri hesaplayabileceğiniz bir satır listesine dönüştürmek için bu 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! İlk diferansiyel gizlilik istatistiğinizi hesapladınız.

Bu grafikte, daha önce hesapladığınız gizliliği korunmuş olmayan sayının yanında, gizliliği korunmuş sayımınızın sonucu gösterilir:

Kodu çalıştırdığınızda elde ettiğiniz çubuk grafik, buradaki grafikten farklı olabilir. Bu durum normaldir. Diferansiyel gizlilikteki gürültü nedeniyle, kodu her çalıştırdığınızda farklı bir çubuk grafik elde edersiniz ancak bunların orijinal, gizli olmayan çubuk grafiğe benzediğini görebilirsiniz.

Gizlilik garantileri için işlem hattının birden fazla kez çalıştırılmaması gerektiğini lütfen unutmayın. Daha fazla bilgi için bkz. Birden fazla istatistik hesaplama.

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

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

Bunun nedeni, çıkış bölümlerinin varlığı kullanıcı verilerine bağlı olduğunda farklı gizlilik garantilerini sağlamak için önemli bir adım olan bölüm seçimi veya eşik belirlemedir. Bu durumda, çıktıda bir bölümün bulunması, verilerde tek bir kullanıcının varlığına dair bilgi sızdırabilir. Bunun neden gizlilik ihlali olarak değerlendirildiği hakkında daha fazla bilgi edinmek için bu blog yayınını inceleyin. PipelineDP, bu gizlilik ihlalini önlemek için yalnızca yeterli sayıda kullanıcı içeren bölümleri saklar.

Çı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. Müşterinin ilk görebileceği tüm olası ürün kategorilerini bildiğiniz için bu durum örneğinizde geçerlidir.

Bölümleri kullanmak için:

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

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

2. Listeyi, run_pipeline() sınıfına ek giriş olarak ayarlayan run_pipeline() işlevine iletin: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)

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

Sonuçta artık tüm bölümlere veya ürünlere ait verilerin raporlandığını görüyorsunuz.

Herkese açık bölümler, daha fazla bölüm tutmanıza olanak tanımakla kalmaz, bölüm seçimi için gizlilik bütçesi harcamadığınızdan yaklaşık olarak yarı yarıya daha az gürültü ekler. Bu nedenle, ham ve özel sayılar arasındaki fark önceki çalıştırmaya kıyasla biraz daha azdır.

Herkese açık bölümleri kullanırken dikkat etmeniz gereken iki önemli nokta vardır:

• Bölüm listesini ham verilerden oluştururken dikkatli olun. Bunu diferansiyel gizlilik sağlayacak şekilde yapmazsanız işlem hattınız artık diferansiyel gizlilik garantisi vermez. Daha fazla bilgi için Gelişmiş: Verilerden bölümler türetme başlıklı makaleyi inceleyin.
• Herkese açık bölümlerin bazılarında 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 yer almayan bir ürün (ör. pantolon) kullandıysanız bu ürün yine de gürültü olarak kabul edilir ve sonuçlarda, ürünlere hiç ziyaret olmamasına rağmen bazı ziyaretler gösterilebilir.

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

Aynı işlem hattında aynı liste genel olmayan çıkış bölümleriyle birden fazla toplama işlemi çalıştırıyorsanız dp_engine.select_private_partitions() yöntemiyle bölümlerin listesini bir kez türetebilir ve bölümleri her toplama işlemine public_partitions girişi olarak sağlayabilirsiniz. Bu yöntem gizlilik açısından güvenli olmasının yanı sıra tüm işlem hattı için yalnızca bir kez bölüm seçimi sırasında gizlilik bütçesini kullandığınızdan daha az gürültü eklemenize de olanak tanır.

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. Birden fazla istatistiği hesaplama

PipelineDP'nin nasıl çalıştığını öğrendiğinize göre, bu aracı daha gelişmiş kullanım alanlarında nasıl kullanabileceğinizi görebilirsiniz. Başlangıçta belirtildiği gibi üç istatistikle ilgileniyorsunuz. PipelineDP, AggregateParams örneğinde aynı parametreleri paylaştıkları sürece aynı anda birden fazla istatistik hesaplamanıza olanak tanır. Bu örneği daha sonra göreceksiniz. Bu yöntem, birden fazla metriğin tek seferde hesaplanmasını daha temiz ve kolay hale getirmenin yanı sıra gizlilik açısından da daha iyidir.

NaiveBudgetAccountant sınıfına sağladığınız epsilon ve delta parametrelerini hatırlıyorsanız bunlar, verilerden sızdırdığınız kullanıcı gizliliği miktarının bir ölçüsü olan gizlilik bütçesi olarak adlandırılan bir şeyi temsil eder.

Gizlilik bütçesiyle ilgili unutulmaması gereken önemli bir nokta, bu bütçenin eklenerek artırılmasıdır. Belirli bir epsilon ε ve delta δ ile bir işlem hattını tek bir kez çalıştırırsanız (ε,δ) bütçesi harcarsınız. İkinci kez çalıştırdığınızda toplam (2ε, 2δ) bütçe harcarsınız. Benzer şekilde, NaiveBudgetAccountant yöntemiyle birden fazla istatistik hesaplayıp ardından ε,δ gizlilik bütçesiyle hesaplama yaparsanız toplamda (2ε, 2δ) bütçe harcamış olursunuz. Bu, gizlilik garantilerini düşürdüğünüz anlamına gelir.

Bunu önlemek için aynı veriler üzerinde birden fazla istatistik hesaplamanız gerektiğinde kullanmak istediğiniz toplam bütçeyle 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ç olarak, aynı genel gizlilik garantisine sahip olursunuz ancak belirli bir toplama işleminin epsilon ve delta değerleri ne kadar yüksek olursa doğruluk da o kadar yüksek olur.

Bu özelliği kullanırken count, mean ve sum istatistiklerini hesaplayabilirsiniz.

İstatistikleri iki farklı metrik üzerinden hesaplarsınız: Önce hangi ürünün görüntülendiğine göre oluşturulan gelir miktarını tahmin etmek için kullandığınız bir conversion_value metriği ve web sitenizi ziyaret eden kullanıcı sayısını ve ortalama dönüşüm oranını hesaplamak için kullandığınız bir has_conversion metriği.

Her metrik için, özel istatistiklerin hesaplanmasını yönlendiren parametreleri ayrı ayrı belirtmeniz gerekir. Gizlilik bütçenizi iki metrik arasında bölersiniz. has_conversion metriğinden iki istatistik hesaplıyorsunuz. Bu nedenle, başlangıç bütçenizin üçte ikisini bu metriğe, diğer üçte birini ise conversion_value metriğine atamak istiyorsunuz.

Birden fazla 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 öğesini başlatın:

 dp_engine = pipeline_dp.DPEngine(budget_accountant, ops)

3. Bu metriğin parametrelerini 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, gizlilik bütçenizin ağırlığını isteğe bağlı olarak belirtir. Hepsine aynı ağırlığı verebilirsiniz ancak bu bağımsız değişkeni daha önce açıklandığı gibi üçte bir olarak ayarlamak istersiniz.

Ayrıca, bir bölümdeki gizlilik birimi tarafından sağlanan değere uygulanan alt ve üst sınırı belirtmek için min_value ve max_value bağımsız değişkenlerini de ayarlarsınız. Bu parametreler, özel bir toplam veya ortalama hesaplamak istediğinizde gereklidir. Negatif değerler beklemediğiniz için 0 ve 100 değerlerinin makul sınırlar olduğunu varsayabilirsiniz.

4. İlgili verileri ayıklayın ve toplama işlevine aktarın:

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. has_conversion değişkeninize göre iki metriği 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, pipeline_dp.AggregateParams örneğinde yapıldı. Artık mean ve count değerlerini toplama olarak tanımlıyor ve gizlilik bütçenizin üçte ikisini bu hesaplamaya atıyorsunuz. Hem istatistikler için aynı katkı sınırlarına sahip olmak hem de bunları aynı has_conversion değişkeni üzerinde hesaplamak istediğiniz için bunları 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 tümünü orijinal istatistikleriyle karşılaştırarak çizebilirsiniz. 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 etrafında simetrik olduğundan, atlayan kullanıcılar için negatif bir dönüşüm oranı ve toplam dönüşüm değeri görürsünüz. Daha fazla analiz ve işleme için gizli istatistikleri manuel olarak sonradan işlememek en iyisidir. Ancak bu grafikleri bir rapora eklemek isterseniz gizlilik garantilerini ihlal etmeden minimum değeri sıfır olarak ayarlayabilirsiniz.

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

Günümüzde veri işleme, yerel olarak işleyemeyeceğiniz kadar büyük miktarda veriyi ele almanızı gerektirir. Bunun yerine, birçok kişi büyük ölçekli veri işleme için Beam veya Spark gibi çerçeveler 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.

private_beam API ile Beam'i kullanarak işlem hattını çalıştırmak için:

1. Bir runner değişkeni başlatın ve ardından gizlilik işlemlerinizi rows'nizin Beam gösterimine uyguladığı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. Gerekli gizlilik parametrelerinizi içeren 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 şartlarınıza uygun olmasını sağlayan bir pcol veya gizli 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 toplama parametrelerinizi 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ırsınız.

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

dp_result = pcol | pbeam.Sum(params)

6. Sonunda kodunuz aşağıdaki 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 ayarlayın

Bu codelab'de epsilon, delta ve max_partitions_contributed parametreleri gibi birçok parametreye değinildi. Bunları kabaca 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 doğrusu, anonimleştirilmiş çıkıştan potansiyel bir saldırganın veriler hakkında ne kadar bilgi edinebileceğinin bir ölçüsüdür. Parametrelerin değeri ne kadar yüksek olursa saldırgan veriler hakkında o kadar fazla bilgi edinir. Bu da gizlilik riski oluşturur. Diğer yandan, epsilon ve delta parametrelerinin değeri ne kadar düşük olursa çıktıyı anonim hale getirmek için o kadar fazla gürültü eklemeniz ve anonimleştirilmiş çıktıda tutmak için her bölümde o kadar fazla benzersiz kullanıcıya ihtiyacınız olur. Bu durumda, fayda ile gizlilik arasında bir denge söz konusudur.

PipelineDP'de, NaiveBudgetAccountant örneğinde toplam gizlilik bütçesini ayarlarken anonimleştirilmiş çıktınız için istediğiniz gizlilik garantilerini belirtmeniz gerekir. Ancak gizlilik garantilerinizin geçerli olmasını istiyorsanız her toplama için ayrı bir NaiveBudgetAccountant örneğini dikkatli bir şekilde kullanmanız veya bütçenizin aşırı kullanılmasını önlemek için işlem hattını birden çok kez çalıştırmanız gerekir.

Diferansiyel gizlilik ve gizlilik parametrelerinin anlamı hakkında daha fazla bilgi için Diferansiyel gizlilikle ilgili okuma listesi başlıklı makaleyi inceleyin.

Yardımcı program parametreleri

Yardımcı program parametreleri, gizlilik garantilerini etkilemez ancak çıktının doğruluğunu ve dolayısıyla faydasını etkiler. 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 toplamalar için geçerli olan bir yardımcı program parametresi max_partitions_contributed parametresidir. Bölüm, 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 sayıda anahtara katkıda bulunursa bazı katkılar, max_partitions_contributed parametresinin tam değerine katkıda bulunacak şekilde bırakılır.

Benzer şekilde, çoğu toplama işleminde max_contributions_per_partition parametresi bulunur. Bu değerler AggregateParams örneğinde de sağlanır ve her toplama için ayrı değerler olabilir. Her anahtar için kullanıcının katkısını sınırlar.

Çıkışa eklenen gürültü, max_partitions_contributed ve max_contributions_per_partition parametreleriyle ölçeklendirilir. Bu nedenle, her parametreye daha büyük değerler atamak daha fazla veri tutmanızı sağlar ancak daha gürültülü bir sonuç elde edersiniz.

Bazı toplamalar, her kullanıcının katkılarının sınırlarını belirten bir min_value ve max_value parametresi gerektirir. Bir kullanıcı, min_value parametresine atanan değerden daha düşük bir değer girerse değer, parametrenin değerine yükseltilir. Benzer şekilde, bir kullanıcı max_value parametresinin değerinden daha büyük bir değer girerse değer, parametrenin değerine düşürülür. Orijinal değerlerin daha fazlasını korumak için daha büyük sınırlar belirtmeniz gerekir. Gürültü, sınırların boyutuna göre ölçeklendirilir. Bu nedenle, daha büyük sınırlar daha fazla veri tutmanıza olanak tanır ancak sonuç daha gürültülü olur.

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

9. Tebrikler

Tebrikler! PipelineDP codelab'ini tamamladınız ve diferansiyel gizlilik ile PipelineDP hakkında çok şey öğrendiniz.

Daha fazla bilgi

• GitHub deposu
• PipelineDP
• Beam'de gizlilik codelab'i