예제 #1
0
import time
import pickle
from compute_delta import get_delta_max

# Params for PLD
L = 10

# Delta
sigma = 5.0
eps = 2.0
nc = 10
nx = 1E6
p = 0.52

dd_max = get_delta_max(target_eps=eps, sigma=sigma, ncomp=nc, nx=nx, L=L, p=p)

from tensorflow_privacy.privacy.analysis import rdp_accountant


def TF_MA(sigma, T, target_delta=None, target_epsilon=None, max_order=32):
    orders = range(2, max_order + 1)
    rdp = np.zeros_like(orders, dtype=float)
    #print(rdp)
    #print(size(rdp))
    for i in orders:
        # RDP for the Gaussian mechanism
        rdp[i - 2] += (T / 2) * i / (2 * sigma**2)
        # RDP for the randomised response
        rdp[i - 2] += (T / 2) * (1 /
                                 (i - 1)) * np.log((p**i) * (1 - p)**(1 - i) +
예제 #2
0
    steps_list = nc*np.ones(len(sigmas))
    orders = range(2, max_order + 1)
    rdp = np.zeros_like(orders, dtype=float)
    rdp += compute_heterogenous_rdp(sp, sigmas, steps_list, orders)
    eps, delta, opt_order = rdp_accountant.get_privacy_spent(orders, rdp, target_delta=target_delta, target_eps=target_epsilon)
    return (eps, delta)

start_tf=0.0
end_tf=0.0
start_pld=0.0
end_pld=0.0

# The main loop
for ii in range(1,len(sigmas)+1):
    start_pld = time.process_time()
    d1 = get_delta_max(target_eps=eps,sigmas=sigmas[:ii],q=q,ncomp=nc,nx=nx,L=L)
    end_pld = time.process_time()
    deltas_pld.append(d1)
    print('d1: ' + str(d1))
    start_tf = time.process_time()
    a,d2 = TF_MA(q, sigmas[:ii], nc, target_epsilon = eps)
    end_tf = time.process_time()
    deltas_tf.append(d2)
    print('d2: ' + str(d2))

tf_t=round(end_tf-start_tf,2)
pld_t=round(end_pld-start_pld,2)
print('tf_t : ' + str(tf_t))
print('pld_t : ' + str(pld_t))

print(deltas_tf)
예제 #3
0
# Delta
eps = 1.0

nxs = [5E4, 1E5, 1E6, 5E6]
deltas_max = []

nc = 500

ss = 2.0
deltas = []
time_slow = []
time_fast = []

for nx in nxs:
    d1, t1 = get_delta_max(target_eps=eps, sigma=ss, q=q, ncomp=nc, nx=nx, L=L)
    d2, t2 = get_delta_max2(target_eps=eps,
                            sigma=ss,
                            q=q,
                            ncomp=nc,
                            nx=nx,
                            L=L)
    deltas.append(d2)
    time_slow.append(t1)
    time_fast.append(t2)

for (i, nx) in enumerate(nxs):
    t1 = time_slow[i] / 0.001
    t2 = time_fast[i] / 0.001
    dd = deltas[i]
    print(('%1d' % nx) + '  &  ' + ('%10.1E' % t1) + ' & ' + ('%10.1E' % t2) +